{"title": "100 doors", "language": "C sharp|C#", "task": "There are 100 doors in a row that are all initially closed. \n\nYou make 100 passes by the doors. \n\nThe first time through, visit every door and  ''toggle''  the door  (if the door is closed,  open it;   if it is open,  close it). \n\nThe second time, only visit every 2nd door   (door #2, #4, #6, ...),   and toggle it.  \n\nThe third time, visit every 3rd door   (door #3, #6, #9, ...), etc,   until you only visit the 100th door.\n\n\n;Task:\nAnswer the question:   what state are the doors in after the last pass?   Which are open, which are closed?\n\n\n'''Alternate:'''  \nAs noted in this page's   discussion page,   the only doors that remain open are those whose numbers are perfect squares.\n\nOpening only those doors is an   optimization   that may also be expressed; \nhowever, as should be obvious, this defeats the intent of comparing implementations across programming languages.\n\n", "solution": "using System;\nusing System.IO;\nusing System.Collections.Generic;\n\nclass Program\n{\n    static void Main()\n    {\n        Console.Clear();\n        Console.WriteLine(\"Input a number of doors to calculate, then press enter\");\n        StartCalculator();\n    }\n    \n    static void StartCalculator()\n    {\n        //The number to calculate is input here\n        string input = Console.ReadLine();\n        Console.Clear();\n        \n        try\n        {\n            //The program attempts to convert the string to an int\n            //Exceptions will be caught on this line\n            int numberOfDoors = Convert.ToInt32(input);\n            \n            //Will call method recursively if input number is less than 1\n            if (numberOfDoors <= 0)\n            {\n                Console.WriteLine(\"Please use a number greater than 0\");\n                StartCalculator();\n            }\n            \n            //The program then starts the calculation process\n            Calculate(numberOfDoors);\n            \n            //After calculation process is finished, restart method is called\n            RestartCalculator();\n        }\n        catch(FormatException)\n        {\n            //Code will be executed if the number has a decimal or has an unrecognizable symbol\n            Console.WriteLine(\"Unable to read. Please use a real number without a decimal\");\n            StartCalculator();\n        }\n        catch (OverflowException)\n        {\n            //Code will be executed if number is too long\n            Console.WriteLine(\"You number is too long\");\n            StartCalculator();\n        }\n    }\n    \n    static void Calculate(int numberOfDoors)\n    {\n        //Increases numberOfDoors by 1 since array starts at 0\n        numberOfDoors++;\n        \n        //Dictionary key represents door number, value represents if the door is open\n        //if value == true, the door is open\n        Dictionary<int, bool> doors = new Dictionary<int, bool>();\n        \n        //Creates Dictionary size of numberOfDoors, all initialized at false\n        for(int i = 0; i < numberOfDoors; i++)\n        {\n            doors.Add(i, false);\n        }\n        \n        //Creates interval between doors, starting at 0, while less than numberOfDoors\n        for (int doorInterval = 0; doorInterval < numberOfDoors; doorInterval++)\n        {\n            //Will alter every cubby at doorInterval\n            //1 needs to be added since doorInterval will start at 0 and end when equal to numberOfDoors\n            for(int i = 0; i < numberOfDoors; i += doorInterval + 1)\n            {\n                //Changes a false value to true and vice versa\n                doors[i] = doors[i] ? false: true;\n            }\n        }\n        \n        //Writes each door and whether it is open or closed\n        for(int i = 0; i < numberOfDoors; i++)\n        {\n            //Skips over door 0\n            if (i == 0) continue;\n            //Writes open if door value is true, writes closed if door value is false\n            Console.WriteLine(\"Door \" + (i) + \" is \" + (doors[i] ? \"open\" : \"closed\"));\n        }\n    }\n    \n    static void RestartCalculator()\n    {   \n        Console.WriteLine(\"Press any key to restart\");\n        Console.ReadKey(true);\n        Main();\n    }\n}\n"}
{"title": "100 prisoners", "language": "C sharp|C# from D", "task": "The Problem:\n* 100 prisoners are individually numbered 1 to 100\n* A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.\n* Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.\n* Prisoners start outside the room\n:* They can decide some strategy before any enter the room.\n:* Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.\n:* A prisoner can open no more than 50 drawers.\n:* A prisoner tries to find his own number.\n:* A prisoner finding his own number is then held apart from the others.\n* If '''all''' 100 prisoners find their own numbers then they will all be pardoned. If ''any'' don't then ''all'' sentences stand. \n\n\n;The task:\n# Simulate several thousand instances of the game where the prisoners randomly open drawers\n# Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:\n:* First opening the drawer whose outside number is his prisoner number.\n:* If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).\n\n\nShow and compare the computed probabilities of success for the two strategies, here, on this page.\n\n\n;References:\n# The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).\n# [[wp:100 prisoners problem]]\n# 100 Prisoners Escape Puzzle DataGenetics.\n# Random permutation statistics#One hundred prisoners on Wikipedia.\n\n", "solution": "using System;\nusing System.Linq;\n\nnamespace Prisoners {\n    class Program {\n        static bool PlayOptimal() {\n            var secrets = Enumerable.Range(0, 100).OrderBy(a => Guid.NewGuid()).ToList();\n\n            for (int p = 0; p < 100; p++) {\n                bool success = false;\n\n                var choice = p;\n                for (int i = 0; i < 50; i++) {\n                    if (secrets[choice] == p) {\n                        success = true;\n                        break;\n                    }\n                    choice = secrets[choice];\n                }\n\n                if (!success) {\n                    return false;\n                }\n            }\n\n            return true;\n        }\n\n        static bool PlayRandom() {\n            var secrets = Enumerable.Range(0, 100).OrderBy(a => Guid.NewGuid()).ToList();\n\n            for (int p = 0; p < 100; p++) {\n                var choices = Enumerable.Range(0, 100).OrderBy(a => Guid.NewGuid()).ToList();\n\n                bool success = false;\n                for (int i = 0; i < 50; i++) {\n                    if (choices[i] == p) {\n                        success = true;\n                        break;\n                    }\n                }\n\n                if (!success) {\n                    return false;\n                }\n            }\n\n            return true;\n        }\n\n        static double Exec(uint n, Func<bool> play) {\n            uint success = 0;\n            for (uint i = 0; i < n; i++) {\n                if (play()) {\n                    success++;\n                }\n            }\n            return 100.0 * success / n;\n        }\n\n        static void Main() {\n            const uint N = 1_000_000;\n            Console.WriteLine(\"# of executions: {0}\", N);\n            Console.WriteLine(\"Optimal play success rate: {0:0.00000000000}%\", Exec(N, PlayOptimal));\n            Console.WriteLine(\" Random play success rate: {0:0.00000000000}%\", Exec(N, PlayRandom));\n        }\n    }\n}"}
{"title": "15 puzzle game", "language": "C sharp 3+", "task": "Implement the Fifteen Puzzle Game.\n\n\nThe   '''15-puzzle'''   is also known as: \n:::*   '''Fifteen Puzzle'''\n:::*   '''Gem Puzzle'''\n:::*   '''Boss Puzzle'''\n:::*   '''Game of Fifteen'''\n:::*   '''Mystic Square'''\n:::*   '''14-15 Puzzle'''\n:::*   and some others.\n\n\n;Related Tasks:\n:*   15 Puzzle Solver\n:*   [[16 Puzzle Game]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Drawing;\nusing System.Windows.Forms;\n\npublic class FifteenPuzzle\n{\n    const int GridSize = 4; //Standard 15 puzzle is 4x4\n    const int BlockCount = 16;\n\n    static readonly Random R = new Random();\n\n    private List<Button> Puzzles = new List<Button>();\n    private int Moves = 0;\n    private DateTime Start;\n\n    public class Puzzle\n    {\n        private int mOrderedNumer;\n\n        public int CurrentNumber;\n\n        public int X;\n        public int Y;\n\n        public int InvX\n        {\n            get { return (GridSize - 1) - X; }\n        }\n        public int InvY\n        {\n            get { return (GridSize - 1) - Y; }\n        }\n\n        public Puzzle(int OrderedNumer)\n        {\n            mOrderedNumer = OrderedNumer;\n\n            CurrentNumber = OrderedNumer;\n\n            X = OrderedNumer % GridSize;\n            Y = OrderedNumer / GridSize;\n        }\n        public Puzzle(int OrderedNumer, int CurrentNumber)\n            : this(OrderedNumer)\n        {\n            this.CurrentNumber = CurrentNumber;\n        }\n\n        public bool IsEmptyPuzzle\n        {\n            get { return CurrentNumber >= (BlockCount - 1); }\n        }\n        public bool IsTruePlace\n        {\n            get { return (CurrentNumber == mOrderedNumer); }\n        }\n        public bool NearestWith(Puzzle OtherPz)\n        {\n            int dx = (X - OtherPz.X);\n            int dy = (Y - OtherPz.Y);\n\n            if ((dx == 0) && (dy <= 1) && (dy >= -1)) return true;\n            if ((dy == 0) && (dx <= 1) && (dx >= -1)) return true;\n\n            return false;\n        }\n\n        public override string ToString()\n        {\n            return (CurrentNumber + 1).ToString();\n        }\n    }\n\n    public static void Main(string[] args)\n    {\n        FifteenPuzzle Game = new FifteenPuzzle();\n        Application.Run(Game.CreateForm());\n    }\n\n    private Form CreateForm()\n    {\n        int ButtonSize = 50;\n        int ButtonMargin = 3;\n        int FormEdge = 9;\n\n        Font ButtonFont = new Font(\"Arial\", 15.75F, FontStyle.Regular);\n\n        Button StartButton = new Button();\n        StartButton.Location = new Point(FormEdge, (GridSize * (ButtonMargin + ButtonSize)) + FormEdge);\n        StartButton.Size = new Size(86, 23);\n        StartButton.Font = new Font(\"Arial\", 9.75F, FontStyle.Regular);\n        StartButton.Text = \"New Game\";\n        StartButton.UseVisualStyleBackColor = true;\n        StartButton.TabStop = false;\n\n        StartButton.Click += new EventHandler(NewGame);\n\n        int FormWidth = (GridSize * ButtonSize) + ((GridSize - 1) * ButtonMargin) + (FormEdge * 2);\n        int FormHeigth = FormWidth + StartButton.Height;\n\n        Form Form = new Form();\n        Form.Text = \"Fifteen\";\n        Form.ClientSize = new Size(FormWidth, FormHeigth);\n        Form.FormBorderStyle = FormBorderStyle.FixedSingle;\n        Form.MaximizeBox = false;\n        Form.SuspendLayout();\n\n        for (int i = 0; i < BlockCount; i++)\n        {\n            Button Bt = new Button();\n            Puzzle Pz = new Puzzle(i);\n\n            int PosX = FormEdge + (Pz.X) * (ButtonSize + ButtonMargin);\n            int PosY = FormEdge + (Pz.Y) * (ButtonSize + ButtonMargin);\n            Bt.Location = new Point(PosX, PosY);\n\n            Bt.Size = new Size(ButtonSize, ButtonSize);\n            Bt.Font = ButtonFont;\n\n            Bt.Text = Pz.ToString();\n            Bt.Tag = Pz;\n            Bt.UseVisualStyleBackColor = true;\n            Bt.TabStop = false;\n\n            Bt.Enabled = false;\n            if (Pz.IsEmptyPuzzle) Bt.Visible = false;\n\n            Bt.Click += new EventHandler(MovePuzzle);\n\n            Puzzles.Add(Bt);\n            Form.Controls.Add(Bt);\n        }\n\n        Form.Controls.Add(StartButton);\n        Form.ResumeLayout();\n\n        return Form;\n    }\n\n    private void NewGame(object Sender, EventArgs E)\n    {\n        do\n        {\n            for (int i = 0; i < Puzzles.Count; i++)\n            {\n                Button Bt1 = Puzzles[R.Next(i, Puzzles.Count)];\n                Button Bt2 = Puzzles[i];\n                Swap(Bt1, Bt2);\n            }\n        }\n        while (!IsSolvable());\n\n        for (int i = 0; i < Puzzles.Count; i++)\n        {\n            Puzzles[i].Enabled = true;\n        }\n\n        Moves = 0;\n        Start = DateTime.Now;\n    }\n\n    private void MovePuzzle(object Sender, EventArgs E)\n    {\n        Button Bt1 = (Button)Sender;\n        Puzzle Pz1 = (Puzzle)Bt1.Tag;\n\n        Button Bt2 = Puzzles.Find(Bt => ((Puzzle)Bt.Tag).IsEmptyPuzzle);\n        Puzzle Pz2 = (Puzzle)Bt2.Tag;\n\n        if (Pz1.NearestWith(Pz2))\n        {\n            Swap(Bt1, Bt2);\n            Moves++;\n        }\n\n        CheckWin();\n    }\n\n    private void CheckWin()\n    {\n        Button WrongPuzzle = Puzzles.Find(Bt => !((Puzzle)Bt.Tag).IsTruePlace);\n        bool UWin = (WrongPuzzle == null);\n\n        if (UWin)\n        {\n            for (int i = 0; i < Puzzles.Count; i++)\n            {\n                Puzzles[i].Enabled = false;\n            }\n\n            TimeSpan Elapsed = DateTime.Now - Start;\n            Elapsed = TimeSpan.FromSeconds(Math.Round(Elapsed.TotalSeconds, 0));\n            MessageBox.Show(String.Format(\"Solved in {0} moves. Time: {1}\", Moves, Elapsed));\n        }\n    }\n\n    private void Swap(Button Bt1, Button Bt2)\n    {\n        if (Bt1 == Bt2) return;\n\n        Puzzle Pz1 = (Puzzle)Bt1.Tag;\n        Puzzle Pz2 = (Puzzle)Bt2.Tag;\n\n        int g = Pz1.CurrentNumber;\n        Pz1.CurrentNumber = Pz2.CurrentNumber;\n        Pz2.CurrentNumber = g;\n\n        Bt1.Visible = true;\n        Bt1.Text = Pz1.ToString();\n        if (Pz1.IsEmptyPuzzle) Bt1.Visible = false;\n\n        Bt2.Visible = true;\n        Bt2.Text = Pz2.ToString();\n        if (Pz2.IsEmptyPuzzle) Bt2.Visible = false;\n    }\n\n    private bool IsSolvable()\n    {\n        // WARNING: size of puzzle board MUST be even(like 4)!\n        // For explain see: https://www.geeksforgeeks.org/check-instance-15-puzzle-solvable/\n\n        int InvCount = 0;\n        for (int i = 0; i < Puzzles.Count - 1; i++)\n        {\n            for (int j = i + 1; j < Puzzles.Count; j++)\n            {\n                Puzzle Pz1 = (Puzzle)Puzzles[i].Tag;\n                if (Pz1.IsEmptyPuzzle) continue;\n\n                Puzzle Pz2 = (Puzzle)Puzzles[j].Tag;\n                if (Pz2.IsEmptyPuzzle) continue;\n\n                if (Pz1.CurrentNumber > Pz2.CurrentNumber) InvCount++;\n            }\n        }\n\n        Button EmptyBt = Puzzles.Find(Bt => ((Puzzle)Bt.Tag).IsEmptyPuzzle);\n        Puzzle EmptyPz = (Puzzle)EmptyBt.Tag;\n\n        bool Result = false;\n        if ((EmptyPz.InvY + 1) % 2 == 0) // is even\n        {\n            // is odd\n            if (InvCount % 2 != 0) Result = true;\n        }\n        else // is odd\n        {\n            // is even\n            if (InvCount % 2 == 0) Result = true;\n        }\n        return Result;\n    }\n}"}
{"title": "21 game", "language": "C sharp|C#", "task": "'''21''' is a two player game, the game is played by choosing \na number ('''1''', '''2''', or '''3''')  to be added to the ''running total''.\n\nThe game is won by the player whose chosen number causes the ''running total''\nto reach ''exactly'' '''21'''.\n\nThe ''running total'' starts at zero. \nOne player will be the computer.\n \nPlayers alternate supplying a number to be added to the ''running total''. \n\n\n;Task:\nWrite a computer program that will:\n::* do the prompting (or provide a button menu), \n::* check for errors and display appropriate error messages, \n::* do the additions (add a chosen number to the ''running total''), \n::* display the ''running total'', \n::* provide a mechanism for the player to quit/exit/halt/stop/close the program,\n::* issue a notification when there is a winner, and\n::* determine who goes first (maybe a random or user choice, or can be specified when the game begins). \n\n", "solution": "// 21 Game \n\nusing System;\n\nnamespace _21Game\n{\n    public class Program\n    {\n        private const string computerPlayer = \"Computer\";\n        private const string humanPlayer = \"Player 1\";\n\n        public static string SwapPlayer(string currentPlayer)\n        {\n            if (currentPlayer == computerPlayer)\n            {\n                currentPlayer = humanPlayer;\n            }\n            else\n            {\n                currentPlayer = computerPlayer;\n            }\n\n            return currentPlayer;\n        }\n\n        public static void PlayGame()\n        {\n            bool playAnother = true;\n            int total = 0;\n            int final = 21;\n            int roundChoice = 0;\n            string currentPlayer = RandomPLayerSelect();\n            int compWins = 0;\n            int humanWins = 0;\n\n            while (playAnother)\n            {\n                Console.WriteLine($\"Now playing: {currentPlayer}\");\n                try\n                {\n                    if (currentPlayer == computerPlayer)\n                    {\n                       roundChoice =  CompMove(total);\n                    }\n                    else\n                    {\n                        roundChoice = int.Parse(Console.ReadLine());\n                    }\n                    \n\n                    if (roundChoice != 1 && roundChoice != 2 && roundChoice != 3)\n                    {\n                        throw new Exception();\n                    }\n\n                    total += roundChoice;\n                }\n                catch (Exception)\n                {\n                    Console.WriteLine(\"Invalid choice! Choose from numbers: 1, 2, 3.\");\n                    continue;\n                }\n\n                Console.WriteLine(total);\n\n                if (total == final)\n                {\n                    if (currentPlayer == computerPlayer)\n                    {\n                        compWins++;\n                    }\n                    if (currentPlayer == humanPlayer)\n                    {\n                        humanWins++;\n                    }\n                    Console.WriteLine($\"Winner: {currentPlayer}\");\n                    Console.WriteLine($\"Comp wins: {compWins}. Human wins: {humanWins}\");\n                    Console.WriteLine($\"do you wan to play another round? y/n\");\n                    var choice = Console.ReadLine();\n                    if (choice == \"y\")\n                    {\n                        total = 0;\n                    }\n                    else if (choice == \"n\")\n                    {\n                        break;\n                    }\n                    else\n                    {\n                        Console.WriteLine(\"Invalid choice! Choose from y or n\");\n                        continue;\n                    }\n                }\n\n                else if (total > 21)\n                {\n                    Console.WriteLine(\"Not the right time to play this game :)\");\n                    break;\n                }\n\n                currentPlayer = SwapPlayer(currentPlayer);\n            }\n        }\n\n        public static bool CheckIfCanWin(int total)\n        {\n            bool result = false;\n            if (total == 18)\n            {\n                result = true;\n            }\n            return result;\n        }\n\n        public static int CompMove(int total)\n        {\n            int choice = 0;\n\n            if (CheckIfCanWin(total))\n            {\n                choice = 21 - total;\n            }\n            else\n            {\n                choice = new Random().Next(1,4);\n            }\n\n            return choice;\n        }\n\n        public static string RandomPLayerSelect()\n        {\n            string[] players = new string[] { computerPlayer, humanPlayer };\n            var random = new Random().Next(0,2);\n            return players[random];\n        }\n\n        public static void Main(string[] args)\n        {\n            // welcome message and rules\n            Console.WriteLine(\"Welcome to 21 game \\n\");\n            Console.WriteLine(@\"21 is a two player game. \nThe game is played by choosing a number.\n1, 2, or 3 to be added a total sum. \\n\nThe game is won by the player reaches exactly 21. \\n\" );            \n            Console.WriteLine(\"Choose your number: (1, 2 or 3)\");\n\n            PlayGame();\n        }\n    }\n}\n\n\n"}
{"title": "24 game/Solve", "language": "C sharp|C#", "task": "Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the [[24 game]].\n\nShow examples of solutions generated by the program.\n\n\n;Related task:\n*   [[Arithmetic Evaluator]]\n\n", "solution": "Generate binary trees -> generate permutations -> create expression -> evaluate expression<br/>\nThis works with other targets and more numbers but it will of course become slower.<br/>\nRedundant expressions are filtered out (based on https://www.4nums.com/theory/) but I'm not sure I caught them all.\n"}
{"title": "24 game/Solve", "language": "C sharp 8", "task": "Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the [[24 game]].\n\nShow examples of solutions generated by the program.\n\n\n;Related task:\n*   [[Arithmetic Evaluator]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing static System.Linq.Enumerable;\n\npublic static class Solve24Game\n{\n    public static void Main2() {\n        var testCases = new [] {\n            new [] { 1,1,2,7 },\n            new [] { 1,2,3,4 },\n            new [] { 1,2,4,5 },\n            new [] { 1,2,7,7 },\n            new [] { 1,4,5,6 },\n            new [] { 3,3,8,8 },\n            new [] { 4,4,5,9 },\n            new [] { 5,5,5,5 },\n            new [] { 5,6,7,8 },\n            new [] { 6,6,6,6 },\n            new [] { 6,7,8,9 },\n        };\n        foreach (var t in testCases) Test(24, t);\n        Test(100, 9,9,9,9,9,9);\n\n        static void Test(int target, params int[] numbers) {\n            foreach (var eq in GenerateEquations(target, numbers)) Console.WriteLine(eq);\n            Console.WriteLine();\n        }\n    }\n\n    static readonly char[] ops = { '*', '/', '+', '-' };\n    public static IEnumerable<string> GenerateEquations(int target, params int[] numbers) {\n        var operators = Repeat(ops, numbers.Length - 1).CartesianProduct().Select(e => e.ToArray()).ToList();\n        return (\n            from pattern in Patterns(numbers.Length)\n            let expression = CreateExpression(pattern)\n            from ops in operators\n            where expression.WithOperators(ops).HasPreferredTree()\n            from permutation in Permutations(numbers)\n            let expr = expression.WithValues(permutation)\n            where expr.Value == target && expr.HasPreferredValues()\n            select $\"{expr.ToString()} = {target}\")\n            .Distinct()\n            .DefaultIfEmpty($\"Cannot make {target} with {string.Join(\", \", numbers)}\");\n    }\n\n    ///<summary>Generates postfix expression trees where 1's represent operators and 0's represent numbers.</summary>\n    static IEnumerable<int> Patterns(int length) {\n        if (length == 1) yield return 0; //0\n        if (length == 2) yield return 1; //001\n        if (length < 3) yield break;\n        //Of each tree, the first 2 bits must always be 0 and the last bit must be 1. Generate the bits in between.\n        length -= 2;\n        int len = length * 2 + 3;\n        foreach (int permutation in BinaryPatterns(length, length * 2)) {\n            (int p, int l) = ((permutation << 1) + 1, len);\n            if (IsValidPattern(ref p, ref l)) yield return (permutation << 1) + 1;\n        }\n    }\n\n    ///<summary>Generates all numbers with the given number of 1's and total length.</summary>\n    static IEnumerable<int> BinaryPatterns(int ones, int length) {\n        int initial = (1 << ones) - 1;\n        int blockMask = (1 << length) - 1;\n        for (int v = initial; v >= initial; ) {\n            yield return v;\n            int w = (v | (v - 1)) + 1;\n            w |= (((w & -w) / (v & -v)) >> 1) - 1;\n            v = w & blockMask;\n        }\n    }\n\n    static bool IsValidPattern(ref int pattern, ref int len) {\n        bool isNumber = (pattern & 1) == 0;\n        pattern >>= 1;\n        len--;\n        if (isNumber) return true;\n        IsValidPattern(ref pattern, ref len);\n        IsValidPattern(ref pattern, ref len);\n        return len == 0;\n    }\n\n    static Expr CreateExpression(int pattern) {\n        return Create();\n\n        Expr Create() {\n            bool isNumber = (pattern & 1) == 0;\n            pattern >>= 1;\n            if (isNumber) return new Const(0);\n            Expr right = Create();\n            Expr left = Create();\n            return new Binary('*', left, right);\n        }\n    }\n\n    static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences) {\n        IEnumerable<IEnumerable<T>> emptyProduct = new[] { Empty<T>() };\n        return sequences.Aggregate(\n            emptyProduct,\n            (accumulator, sequence) =>\n                from acc in accumulator\n                from item in sequence\n                select acc.Concat(new [] { item }));\n    }\n\n    private static List<int> helper = new List<int>();\n    public static IEnumerable<T[]> Permutations<T>(params T[] input) {\n        if (input == null || input.Length == 0) yield break;\n        helper.Clear();\n        for (int i = 0; i < input.Length; i++) helper.Add(i);\n        while (true) {\n            yield return input;\n            int cursor = helper.Count - 2;\n            while (cursor >= 0 && helper[cursor] > helper[cursor + 1]) cursor--;\n            if (cursor < 0) break;\n            int i = helper.Count - 1;\n            while (i > cursor && helper[i] < helper[cursor]) i--;\n            (helper[cursor], helper[i]) = (helper[i], helper[cursor]);\n            (input[cursor], input[i]) = (input[i], input[cursor]);\n            int firstIndex = cursor + 1;\n            for (int lastIndex = helper.Count - 1; lastIndex > firstIndex; ++firstIndex, --lastIndex) {\n                (helper[firstIndex], helper[lastIndex]) = (helper[lastIndex], helper[firstIndex]);\n                (input[firstIndex], input[lastIndex]) = (input[lastIndex], input[firstIndex]);\n            }\n        }\n    }\n\n    static Expr WithOperators(this Expr expr, char[] operators) {\n        int i = 0;\n        SetOperators(expr, operators, ref i);\n        return expr;\n\n        static void SetOperators(Expr expr, char[] operators, ref int i) {\n            if (expr is Binary b) {\n                b.Symbol = operators[i++];\n                SetOperators(b.Right, operators, ref i);\n                SetOperators(b.Left, operators, ref i);\n            }\n        }\n    }\n\n    static Expr WithValues(this Expr expr, int[] values) {\n        int i = 0;\n        SetValues(expr, values, ref i);\n        return expr;\n\n        static void SetValues(Expr expr, int[] values, ref int i) {\n            if (expr is Binary b) {\n                SetValues(b.Left, values, ref i);\n                SetValues(b.Right, values, ref i);\n            } else {\n                expr.Value = values[i++];\n            }\n        }\n    }\n\n    static bool HasPreferredTree(this Expr expr) => expr switch {\n        Const _ => true,\n    \n        // a / b * c => a * c / b\n        ((_, '/' ,_), '*', _) => false,\n        // c + a * b => a * b + c\n        (var l, '+', (_, '*' ,_) r) when l.Depth < r.Depth => false,\n        // c + a / b => a / b + c\n        (var l, '+', (_, '/' ,_) r) when l.Depth < r.Depth => false,\n        // a * (b + c) => (b + c) * a\n        (var l, '*', (_, '+' ,_) r) when l.Depth < r.Depth => false,\n        // a * (b - c) => (b - c) * a\n        (var l, '*', (_, '-' ,_) r) when l.Depth < r.Depth => false,\n        // (a +- b) + (c */ d) => ((c */ d) + a) +- b\n        ((_, var p, _), '+', (_, var q, _)) when \"+-\".Contains(p) && \"*/\".Contains(q) => false,\n        // a + (b + c) => (a + b) + c\n        (var l, '+', (_, '+' ,_) r) => false,\n        // a + (b - c) => (a + b) - c\n        (var l, '+', (_, '-' ,_) r) => false,\n        // a - (b + c) => (a - b) + c\n        (_, '-', (_, '+', _)) => false,\n        // a * (b * c) => (a * b) * c\n        (var l, '*', (_, '*' ,_) r) => false,\n        // a * (b / c) => (a * b) / c\n        (var l, '*', (_, '/' ,_) r) => false,\n        // a / (b / c) => (a * c) / b\n        (var l, '/', (_, '/' ,_) r) => false,\n        // a - (b - c) * d => (c - b) * d + a\n        (_, '-', ((_, '-' ,_), '*', _)) => false,\n        // a - (b - c) / d => (c - b) / d + a\n        (_, '-', ((_, '-' ,_), '/', _)) => false,\n        // a - (b - c) => a + c - b\n        (_, '-', (_, '-', _)) => false,\n        // (a - b) + c => (a + c) - b\n        ((_, '-', var b), '+', var c) => false,\n\n        (var l, _, var r) => l.HasPreferredTree() && r.HasPreferredTree()\n    };\n\n    static bool HasPreferredValues(this Expr expr) => expr switch {\n        Const _ => true,\n\n        // -a + b => b - a\n        (var l, '+', var r) when l.Value < 0 && r.Value >= 0 => false,\n        // b * a => a * b\n        (var l, '*', var r) when l.Depth == r.Depth && l.Value > r.Value => false,\n        // b + a => a + b\n        (var l, '+', var r) when l.Depth == r.Depth && l.Value > r.Value => false,\n        // (b o c) * (a o d) => (a o d) * (b o c)\n        ((var a, _, _) l, '*', (var c, _, _) r) when l.Value == r.Value && l.Depth == r.Depth && a.Value < c.Value => false,\n        // (b o c) + (a o d) => (a o d) + (b o c)\n        ((var a, var p, _) l, '+', (var c, var q, _) r) when l.Value == r.Value && l.Depth == r.Depth && a.Value < c.Value => false,\n        // (a * c) * b => (a * b) * c\n        ((_, '*', var c), '*', var b) when b.Value < c.Value => false,\n        // (a + c) + b => (a + b) + c\n        ((_, '+', var c), '+', var b) when b.Value < c.Value => false,\n        // (a - b) - c => (a - c) - b\n        ((_, '-', var b), '-', var c) when b.Value < c.Value => false,\n        // a / 1 => a * 1\n        (_, '/', var b) when b.Value == 1 => false,\n        // a * b / b => a + b - b\n        ((_, '*', var b), '/', var c) when b.Value == c.Value => false,\n        // a * 1 * 1 => a + 1 - 1\n        ((_, '*', var b), '*', var c) when b.Value == 1 && c.Value == 1 => false,\n\n        (var l, _, var r) => l.HasPreferredValues() && r.HasPreferredValues()\n    };\n\n    private struct Fraction : IEquatable<Fraction>, IComparable<Fraction>\n    {\n        public readonly int Numerator, Denominator;\n\n        public Fraction(int numerator, int denominator)\n            => (Numerator, Denominator) = (numerator, denominator) switch\n        {\n            (_, 0) => (Math.Sign(numerator), 0),\n            (0, _) => (0, 1),\n            (_, var d) when d < 0 => (-numerator, -denominator),\n            _ => (numerator, denominator)\n        };\n\n        public static implicit operator Fraction(int i) => new Fraction(i, 1);\n        public static Fraction operator +(Fraction a, Fraction b) =>\n            new Fraction(a.Numerator * b.Denominator + a.Denominator * b.Numerator, a.Denominator * b.Denominator);\n        public static Fraction operator -(Fraction a, Fraction b) =>\n            new Fraction(a.Numerator * b.Denominator + a.Denominator * -b.Numerator, a.Denominator * b.Denominator);\n        public static Fraction operator *(Fraction a, Fraction b) =>\n            new Fraction(a.Numerator * b.Numerator, a.Denominator * b.Denominator);\n        public static Fraction operator /(Fraction a, Fraction b) =>\n            new Fraction(a.Numerator * b.Denominator, a.Denominator * b.Numerator);\n\n        public static bool operator ==(Fraction a, Fraction b) => a.CompareTo(b) == 0;\n        public static bool operator !=(Fraction a, Fraction b) => a.CompareTo(b) != 0;\n        public static bool operator  <(Fraction a, Fraction b) => a.CompareTo(b)  < 0;\n        public static bool operator  >(Fraction a, Fraction b) => a.CompareTo(b)  > 0;\n        public static bool operator <=(Fraction a, Fraction b) => a.CompareTo(b) <= 0;\n        public static bool operator >=(Fraction a, Fraction b) => a.CompareTo(b) >= 0;\n\n        public bool Equals(Fraction other) => Numerator == other.Numerator && Denominator == other.Denominator;\n        public override string ToString() => Denominator == 1 ? Numerator.ToString() : $\"[{Numerator}/{Denominator}]\";\n\n        public int CompareTo(Fraction other) => (Numerator, Denominator, other.Numerator, other.Denominator) switch {\n            var (    n1, d1,     n2, d2) when n1 == n2 && d1 == d2 => 0,\n                (     0,  0,      _,  _) => (-1),\n                (     _,  _,      0,  0) => 1,\n            var (    n1, d1,     n2, d2) when d1 == d2 => n1.CompareTo(n2),\n                (var n1,  0,      _,  _) => Math.Sign(n1),\n                (     _,  _, var n2,  0) => Math.Sign(n2),\n            var (    n1, d1,     n2, d2) => (n1 * d2).CompareTo(n2 * d1)\n        };\n    }\n\n    private abstract class Expr\n    {\n        protected Expr(char symbol) => Symbol = symbol;\n        public char Symbol { get; set; }\n        public abstract Fraction Value { get; set; }\n        public abstract int Depth { get; }\n        public abstract void Deconstruct(out Expr left, out char symbol, out Expr right);\n    }\n\n    private sealed class Const : Expr\n    {\n        public Const(Fraction value) : base('c') => Value = value;\n        public override Fraction Value { get; set; }\n        public override int Depth => 0;\n        public override void Deconstruct(out Expr left, out char symbol, out Expr right) => (left, symbol, right) = (this, Symbol, this);\n        public override string ToString() => Value.ToString();\n    }\n\n    private sealed class Binary : Expr\n    {\n        public Binary(char symbol, Expr left, Expr right) : base(symbol) => (Left, Right) = (left, right);\n        public Expr Left { get; }\n        public Expr Right { get; }\n        public override int Depth => Math.Max(Left.Depth, Right.Depth) + 1;\n        public override void Deconstruct(out Expr left, out char symbol, out Expr right) => (left, symbol, right) = (Left, Symbol, Right);\n\n        public override Fraction Value {\n            get => Symbol switch {\n                '*' => Left.Value * Right.Value,\n                '/' => Left.Value / Right.Value,\n                '+' => Left.Value + Right.Value,\n                '-' => Left.Value - Right.Value,\n                _ => throw new InvalidOperationException() };\n            set {}\n        }\n\n        public override string ToString() => Symbol switch {\n            '*' => ToString(\"+-\".Contains(Left.Symbol), \"+-\".Contains(Right.Symbol)),\n            '/' => ToString(\"+-\".Contains(Left.Symbol), \"*/+-\".Contains(Right.Symbol)),\n            '+' => ToString(false, false),\n            '-' => ToString(false, \"+-\".Contains(Right.Symbol)),\n            _ => $\"[{Value}]\"\n        };\n\n        private string ToString(bool wrapLeft, bool wrapRight) =>\n            $\"{(wrapLeft ? $\"({Left})\" : $\"{Left}\")} {Symbol} {(wrapRight ? $\"({Right})\" : $\"{Right}\")}\";\n    }\n}"}
{"title": "4-rings or 4-squares puzzle", "language": "C sharp|C# from Java", "task": "Replace       '''a, b, c, d, e, f,'''   and\n  '''g '''       with the decimal\ndigits   LOW   --->   HIGH\nsuch that the sum of the letters inside of each of the four large squares add up to\nthe same sum.\n\n\n            +--------------+      +--------------+\n            |              |      |              |\n            |      a       |      |      e       |\n            |              |      |              |\n            |          +---+------+---+      +---+---------+\n            |          |   |      |   |      |   |         |\n            |          | b |      | d |      | f |         |\n            |          |   |      |   |      |   |         |\n            |          |   |      |   |      |   |         |\n            +----------+---+      +---+------+---+         |\n                       |       c      |      |      g      |\n                       |              |      |             |\n                       |              |      |             |\n                       +--------------+      +-------------+\n\n\nShow all output here.\n\n\n:*   Show all solutions for each letter being unique with\n         LOW=1     HIGH=7\n:*   Show all solutions for each letter being unique with\n         LOW=3     HIGH=9\n:*   Show only the   ''number''   of solutions when each letter can be non-unique\n         LOW=0     HIGH=9\n\n\n;Related task:\n* [[Solve the no connection puzzle]]\n\n", "solution": "using System;\nusing System.Linq;\n\nnamespace Four_Squares_Puzzle {\n    class Program {\n        static void Main(string[] args) {\n            fourSquare(1, 7, true, true);\n            fourSquare(3, 9, true, true);\n            fourSquare(0, 9, false, false);\n        }\n\n        private static void fourSquare(int low, int high, bool unique, bool print) {\n            int count = 0;\n\n            if (print) {\n                Console.WriteLine(\"a b c d e f g\");\n            }\n            for (int a = low; a <= high; ++a) {\n                for (int b = low; b <= high; ++b) {\n                    if (notValid(unique, b, a)) continue;\n\n                    int fp = a + b;\n                    for (int c = low; c <= high; ++c) {\n                        if (notValid(unique, c, b, a)) continue;\n                        for (int d = low; d <= high; ++d) {\n                            if (notValid(unique, d, c, b, a)) continue;\n                            if (fp != b + c + d) continue;\n\n                            for (int e = low; e <= high; ++e) {\n                                if (notValid(unique, e, d, c, b, a)) continue;\n                                for (int f = low; f <= high; ++f) {\n                                    if (notValid(unique, f, e, d, c, b, a)) continue;\n                                    if (fp != d + e + f) continue;\n\n                                    for (int g = low; g <= high; ++g) {\n                                        if (notValid(unique, g, f, e, d, c, b, a)) continue;\n                                        if (fp != f + g) continue;\n\n                                        ++count;\n                                        if (print) {\n                                            Console.WriteLine(\"{0} {1} {2} {3} {4} {5} {6}\", a, b, c, d, e, f, g);\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n            if (unique) {\n                Console.WriteLine(\"There are {0} unique solutions in [{1}, {2}]\", count, low, high);\n            }\n            else {\n                Console.WriteLine(\"There are {0} non-unique solutions in [{1}, {2}]\", count, low, high);\n            }\n        }\n\n        private static bool notValid(bool unique, int needle, params int[] haystack) {\n            return unique && haystack.Any(p => p == needle);\n        }\n    }\n}"}
{"title": "99 bottles of beer", "language": "C sharp|C#", "task": "Display the complete lyrics for the song:     '''99 Bottles of Beer on the Wall'''. \n\n\n;The beer song:\nThe lyrics follow this form:\n\n\n:::              99 bottles of beer on the wall\n:::              99 bottles of beer\n:::              Take one down, pass it around\n:::              98 bottles of beer on the wall\n    \n:::              98 bottles of beer on the wall\n:::              98 bottles of beer\n:::              Take one down, pass it around\n:::              97 bottles of beer on the wall\n\n\n... and so on, until reaching   '''0'''     (zero).\n\nGrammatical support for   ''1 bottle of beer''   is optional. \n\nAs with any puzzle, try to do it in as creative/concise/comical a way \nas possible (simple, obvious solutions allowed, too).\n\n\n\n\n;See also: \n*   http://99-bottles-of-beer.net/\n*   [[:Category:99_Bottles_of_Beer]]\n*   [[:Category:Programming language families]]\n*   Wikipedia 99 bottles of beer\n\n", "solution": "using System;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        for (int i = 99; i > -1; i--)\n        {\n            if (i == 0)\n            {\n                Console.WriteLine(\"No more bottles of beer on the wall, no more bottles of beer.\");\n                Console.WriteLine(\"Go to the store and buy some more, 99 bottles of beer on the wall.\");\n                break;\n            }\n            if (i == 1)\n            {\n                Console.WriteLine(\"1 bottle of beer on the wall, 1 bottle of beer.\");\n                Console.WriteLine(\"Take one down and pass it around, no more bottles of beer on the wall.\");\n                Console.WriteLine();\n            }\n            else\n            {\n                Console.WriteLine(\"{0} bottles of beer on the wall, {0} bottles of beer.\", i);\n                Console.WriteLine(\"Take one down and pass it around, {0} bottles of beer on the wall.\", i - 1);\n                Console.WriteLine();\n            }\n        }\n    }\n}"}
{"title": "99 bottles of beer", "language": "C sharp", "task": "Display the complete lyrics for the song:     '''99 Bottles of Beer on the Wall'''. \n\n\n;The beer song:\nThe lyrics follow this form:\n\n\n:::              99 bottles of beer on the wall\n:::              99 bottles of beer\n:::              Take one down, pass it around\n:::              98 bottles of beer on the wall\n    \n:::              98 bottles of beer on the wall\n:::              98 bottles of beer\n:::              Take one down, pass it around\n:::              97 bottles of beer on the wall\n\n\n... and so on, until reaching   '''0'''     (zero).\n\nGrammatical support for   ''1 bottle of beer''   is optional. \n\nAs with any puzzle, try to do it in as creative/concise/comical a way \nas possible (simple, obvious solutions allowed, too).\n\n\n\n\n;See also: \n*   http://99-bottles-of-beer.net/\n*   [[:Category:99_Bottles_of_Beer]]\n*   [[:Category:Programming language families]]\n*   Wikipedia 99 bottles of beer\n\n", "solution": "string[] bottles = { \t\"80 Shilling\",\n\t\t\t\"Abita Amber\",\n\t\t\t\"Adams Broadside Ale\",\n\t\t\t\"Altenm\u00fcnster Premium\",\n\t\t\t\"August Schell's SnowStorm\",\n\t\t\t\"Bah Humbug! Christmas Ale\",\n\t\t\t\"Beck's Oktoberfest\",\n\t\t\t\"Belhaven Wee Heavy\",\n\t\t\t\"Bison Chocolate Stout\",\n\t\t\t\"Blue Star Wheat Beer\",\n\t\t\t\"Bridgeport Black Strap Stout\",\n\t\t\t\"Brother Thelonius Belgian-Style Abbey Ale\",\n\t\t\t\"Capital Blonde Doppelbock\",\n\t\t\t\"Carta Blanca\",\n\t\t\t\"Celis Raspberry Wheat\",\n\t\t\t\"Christian Moerlein Select Lager\",\n\t\t\t\"Corona\",\n\t\t\t\"Czechvar\",\n\t\t\t\"Delirium Tremens\",\n\t\t\t\"Diamond Bear Southern Blonde\",\n\t\t\t\"Don De Dieu\",\n\t\t\t\"Eastside Dark\",\n\t\t\t\"Eliot Ness\",\n\t\t\t\"Flying Dog K-9 Cruiser Altitude Ale\",\n\t\t\t\"Fuller's London Porter\",\n\t\t\t\"Gaffel K\u00f6lsch\",\n\t\t\t\"Golden Horseshoe\",\n\t\t\t\"Guinness Pub Draught\",\n\t\t\t\"Hacker-Pschorr Weisse\",\n\t\t\t\"Hereford & Hops Black Spring Double Stout\",\n\t\t\t\"Highland Oatmeal Porter\",\n\t\t\t\"Ipswich Ale\",\n\t\t\t\"Iron City\",\n\t\t\t\"Jack Daniel's Amber Lager\",\n\t\t\t\"Jamaica Sunset India Pale Ale\",\n\t\t\t\"Killian's Red\",\n\t\t\t\"K\u00f6nig Ludwig Weiss\",\n\t\t\t\"Kronenbourg 1664\",\n\t\t\t\"Lagunitas Hairy Eyball Ale\",\n\t\t\t\"Left Hand Juju Ginger\",\n\t\t\t\"Locktender Lager\",\n\t\t\t\"Magic Hat Blind Faith\",\n\t\t\t\"Missing Elf Double Bock\",\n\t\t\t\"Muskoka Cream Ale \",\n\t\t\t\"New Glarus Cherry Stout\",\n\t\t\t\"Nostradamus Bruin\",\n\t\t\t\"Old Devil\",\n\t\t\t\"Ommegang Three Philosophers\",\n\t\t\t\"Paulaner Hefe-Weizen Dunkel\",\n\t\t\t\"Perla Chmielowa Pils\",\n\t\t\t\"Pete's Wicked Springfest\",\n\t\t\t\"Point White Biere\",\n\t\t\t\"Prostel Alkoholfrei\",\n\t\t\t\"Quilmes\",\n\t\t\t\"Rahr's Red\",\n\t\t\t\"Rebel Garnet\",\n\t\t\t\"Rickard's Red\",\n\t\t\t\"Rio Grande Elfego Bock\",\n\t\t\t\"Rogue Brutal Bitter\",\n\t\t\t\"Roswell Alien Amber Ale\",\n\t\t\t\"Russian River Pliny The Elder\",\n\t\t\t\"Samuel Adams Blackberry Witbier\",\n\t\t\t\"Samuel Smith's Taddy Porter\",\n\t\t\t\"Schlafly Pilsner\",\n\t\t\t\"Sea Dog Wild Blueberry Wheat Ale\",\n\t\t\t\"Sharp's\",\n\t\t\t\"Shiner 99\",\n\t\t\t\"Sierra Dorada\",\n\t\t\t\"Skullsplitter Orkney Ale\",\n\t\t\t\"Snake Chaser Irish Style Stout\",\n\t\t\t\"St. Arnold Bock\",\n\t\t\t\"St. Peter's Cream Stout\",\n\t\t\t\"Stag\",\n\t\t\t\"Stella Artois\",\n\t\t\t\"Stone Russian Imperial Stout\",\n\t\t\t\"Sweetwater Happy Ending Imperial Stout\",\n\t\t\t\"Taiwan Gold Medal\",\n\t\t\t\"Terrapin Big Hoppy Monster\",\n\t\t\t\"Thomas Hooker American Pale Ale\",\n\t\t\t\"Tie Die Red Ale\",\n\t\t\t\"Toohey's Premium\",\n\t\t\t\"Tsingtao\",\n\t\t\t\"Ugly Pug Black Lager\",\n\t\t\t\"Unibroue Qatre-Centieme\",\n\t\t\t\"Victoria Bitter\",\n\t\t\t\"Voll-Damm Doble Malta\",\n\t\t\t\"Wailing Wench Ale\",\n\t\t\t\"Warsteiner Dunkel\",\n\t\t\t\"Wellhead Crude Oil Stout\",\n\t\t\t\"Weyerbacher Blithering Idiot Barley-Wine Style Ale\",\n\t\t\t\"Wild Boar Amber\",\n\t\t\t\"W\u00fcrzburger Oktoberfest\",\n\t\t\t\"Xingu Black Beer\",\n\t\t\t\"Yanjing\",\n\t\t\t\"Younger's Tartan Special\",\n\t\t\t\"Yuengling Black & Tan\",\n\t\t\t\"Zagorka Special\",\n\t\t\t\"Zig Zag River Lager\",\n\t\t\t\"Zywiec\" };\n\n\nint bottlesLeft = 99;\nconst int FIRST_LINE_SINGULAR = 98;\nconst int FINAL_LINE_SINGULAR = 97;\nstring firstLine = \"\";\nstring finalLine = \"\";\n\n\nfor (int i = 0; i < 99; i++)\n{\n\tfirstLine = bottlesLeft.ToString() + \" bottle\";\n\tif (i != FIRST_LINE_SINGULAR)\n\t    firstLine += \"s\";\n\tfirstLine += \" of beer on the wall, \" + bottlesLeft.ToString() + \" bottle\";\n\tif (i != FIRST_LINE_SINGULAR)\n\t    firstLine += \"s\";\n\tfirstLine += \" of beer\";\n\n\tConsole.WriteLine(firstLine);\n\tConsole.WriteLine(\"Take the \" + bottles[i] + \" down, pass it around,\");\n\tbottlesLeft--;\n\n\tfinalLine = bottlesLeft.ToString() + \" bottle\";\n\tif (i != FINAL_LINE_SINGULAR)\n\t    finalLine += \"s\";\n\tfinalLine += \" of beer on the wall!\";\n\n\tConsole.WriteLine(finalLine);\n\tConsole.WriteLine();\n\tConsole.ReadLine();\n}"}
{"title": "9 billion names of God the integer", "language": "C sharp|C# from Python", "task": "This task is a variation of the short story by Arthur C. Clarke.\n \n(Solvers should be aware of the consequences of completing this task.)\n\nIn detail, to specify what is meant by a   \"name\":\n:The integer 1 has 1 name       \"1\".\n:The integer 2 has 2 names   \"1+1\",   and   \"2\".\n:The integer 3 has 3 names   \"1+1+1\",   \"2+1\",   and   \"3\".\n:The integer 4 has 5 names   \"1+1+1+1\",   \"2+1+1\",   \"2+2\",   \"3+1\",   \"4\".\n:The integer 5 has 7 names   \"1+1+1+1+1\",   \"2+1+1+1\",   \"2+2+1\",   \"3+1+1\",   \"3+2\",   \"4+1\",   \"5\".\n\n\n;Task\nDisplay the first 25 rows of a number triangle which begins:\n\n                                      1\n                                    1   1\n                                  1   1   1 \n                                1   2   1   1\n                              1   2   2   1   1\n                            1   3   3   2   1   1\n\n\nWhere row   n   corresponds to integer   n,   and each column   C   in row   m   from left to right corresponds to the number of names beginning with   C.\n\nA function   G(n)   should return the sum of the   n-th   row. \n\nDemonstrate this function by displaying:   G(23),   G(123),   G(1234),   and   G(12345).  \n\nOptionally note that the sum of the   n-th   row   P(n)   is the      integer partition function. \n\nDemonstrate this is equivalent to   G(n)   by displaying:   P(23),   P(123),   P(1234),   and   P(12345).\n\n\n;Extra credit\n\nIf your environment is able, plot   P(n)   against   n   for   n=1\\ldots 999.\n\n;Related tasks\n* [[Partition function P]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Numerics;\n\nnamespace NamesOfGod\n{\n    public class RowSummer\n    {\n        const int N = 100000;\n        public BigInteger[] p;\n\n        private void calc(int n)\n            /* Translated from C */\n        {\n            p[n] = 0;\n\n            for (int k = 1; k <= n; k++)\n            {\n                int d = n - k * (3 * k - 1) / 2;\n                if (d < 0) break;\n\n                if ((k & 1) != 0) p[n] += p[d];\n                else p[n] -= p[d];\n\n                d -= k;\n                if (d < 0) break;\n\n                if ((k & 1) != 0) p[n] += p[d];\n                else p[n] -= p[d];\n            }\n\n        }\n        public void PrintSums()\n            /* translated from C */\n        {\n            p = new BigInteger[N + 1];\n            var idx = new int[] { 23, 123, 1234, 12345, 20000, 30000, 40000, 50000, N, 0 };\n            int at = 0;\n\n            p[0] = 1;\n\n            for (int i = 1; idx[at] > 0; i++)\n            {\n                calc(i);\n                if (i != idx[at]) continue;\n                Console.WriteLine(i + \":\\t\" + p[i]);\n                at++;\n            }\n        }\n    }\n\n    public class RowPrinter\n        /* translated from Python */\n    {\n        List<List<int>> cache;\n        public RowPrinter()\n        {\n            cache = new List<List<int>> { new List<int> { 1 } };\n        }\n        public List<int> cumu(int n)\n        {\n            for (int l = cache.Count; l < n + 1; l++)\n            {\n                var r = new List<int> { 0 };\n                for (int x = 1; x < l + 1; x++)\n                    r.Add(r.Last() + cache[l - x][Math.Min(x, l - x)]);\n                cache.Add(r);\n            }\n            return cache[n];\n        }\n        public List<int> row(int n)\n        {\n            var r = cumu(n);\n            return (from i in Enumerable.Range(0, n) select r[i + 1] - r[i]).ToList();\n        }\n        public void PrintRows()\n        {\n            var rows = Enumerable.Range(1, 25).Select(x => string.Join(\" \", row(x))).ToList();\n            var widest = rows.Last().Length;\n            foreach (var r in rows)\n                Console.WriteLine(new String(' ', (widest - r.Length) / 2) + r);\n        }\n    }\n\n    class Program\n    {\n        static void Main(string[] args) \n        {\n            var rpr = new RowPrinter();\n            rpr.PrintRows();\n            var ros = new RowSummer();\n            ros.PrintSums();\n            Console.ReadLine();\n        }\n    }\n}\n"}
{"title": "A+B", "language": "C sharp|C#", "task": "'''A+B'''   --- a classic problem in programming contests,   it's given so contestants can gain familiarity with the online judging system being used.\n\n\n;Task:\nGiven two integers,   '''A''' and '''B'''. \n\nTheir sum needs to be calculated.\n\n\n;Input data:\nTwo integers are written in the input stream, separated by space(s):\n: (-1000 \\le A,B \\le +1000)\n\n\n;Output data:\nThe required output is one integer:   the sum of '''A''' and '''B'''.\n\n\n;Example:\n::{|class=\"standard\"\n ! input  \n ! output  \n |-\n | 2 2 \n | 4 \n |-\n | 3 2 \n | 5 \n |}\n\n", "solution": "using System;\n\nclass Program\n{\n    static void Main()\n    {\n        string input = Console.ReadLine();\n        int index = input.IndexOf(\" \");\n        int num1 = int.Parse(input.Substring(0, index));\n        int num2 = int.Parse(input.Substring(index + 1));\n        int sum = num1 + num2;\n        Console.WriteLine(sum.ToString());\n    }\n}"}
{"title": "ABC problem", "language": "C sharp|C#", "task": "You are given a collection of ABC blocks   (maybe like the ones you had when you were a kid).  \n\nThere are twenty blocks with two letters on each block. \n\nA complete alphabet is guaranteed amongst all sides of the blocks. \n\nThe sample collection of blocks: \n  (B O)\n  (X K)\n  (D Q)\n  (C P)\n  (N A)\n  (G T)\n  (R E)\n  (T G)\n  (Q D)\n  (F S)\n  (J W)\n  (H U)\n  (V I)\n  (A N)\n  (O B)\n  (E R)\n  (F S)\n  (L Y)\n  (P C)\n  (Z M)\n\n\n;Task:\nWrite a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks. \n\n\nThe rules are simple:\n::#   Once a letter on a block is used that block cannot be used again\n::#   The function should be case-insensitive\n::#   Show the output on this page for the following 7 words in the following example\n\n\n;Example:\n    >>> can_make_word(\"A\")\n    True\n    >>> can_make_word(\"BARK\")\n    True\n    >>> can_make_word(\"BOOK\")\n    False\n    >>> can_make_word(\"TREAT\")\n    True\n    >>> can_make_word(\"COMMON\")\n    False\n    >>> can_make_word(\"SQUAD\")\n    True\n    >>> can_make_word(\"CONFUSE\")\n    True\n\n", "solution": "using System;\nusing System.IO;\n// Needed for the method.\nusing System.Text.RegularExpressions;\nusing System.Collections.Generic;\n\nvoid Main()\n{\n   string blocks = \"BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM\";\n   List<string> words = new List<string>() {\n      \"A\", \"BARK\", \"BOOK\", \"TREAT\", \"COMMON\", \"SQUAD\", \"CONFUSE\"\n   };\n\n   foreach(var word in words)\n   {\n      Console.WriteLine(\"{0}: {1}\", word, CheckWord(blocks, word));\n   }\n}\n\nbool CheckWord(string blocks, string word)\n{\n   for(int i = 0; i < word.Length; ++i)\n   {\n      int length = blocks.Length;\n      Regex rgx = new Regex(\"([a-z]\"+word[i]+\"|\"+word[i]+\"[a-z])\", RegexOptions.IgnoreCase);\n      blocks = rgx.Replace(blocks, \"\", 1);\n      if(blocks.Length == length) return false;\n   }\n   return true;\n}\n"}
{"title": "Abbreviations, automatic", "language": "C sharp|C#", "task": "The use of   abbreviations    (also sometimes called synonyms, nicknames, AKAs, or aliases)    can be an\neasy way to add flexibility when specifying or using commands, sub-commands, options, etc.\n\n\n\nIt would make a list of words easier to maintain   (as words are added, changed, and/or deleted)   if\nthe minimum abbreviation length of that list could be automatically (programmatically) determined.\n\n\nFor this task, use the list (below) of the days-of-the-week names that are expressed in about a hundred languages   (note that there is a blank line in the list).\n\nSunday Monday Tuesday Wednesday Thursday Friday Saturday\nSondag Maandag Dinsdag Woensdag Donderdag Vrydag Saterdag\nE_djele E_hene E_marte E_merkure E_enjte E_premte E_shtune\nEhud Segno Maksegno Erob Hamus Arbe Kedame\nAl_Ahad Al_Ithinin Al_Tholatha'a Al_Arbia'a Al_Kamis Al_Gomia'a Al_Sabit\nGuiragui Yergou_shapti Yerek_shapti Tchorek_shapti Hink_shapti Ourpat Shapat\ndomingu llunes martes miercoles xueves vienres sabadu\nBazar_gUnU Birinci_gUn Ckinci_gUn UcUncU_gUn DOrdUncU_gUn Bes,inci_gUn Altonco_gUn\nIgande Astelehen Astearte Asteazken Ostegun Ostiral Larunbat\nRobi_bar Shom_bar Mongal_bar Budhh_bar BRihashpati_bar Shukro_bar Shoni_bar\nNedjelja Ponedeljak Utorak Srijeda Cxetvrtak Petak Subota\nDisul Dilun Dimeurzh Dimerc'her Diriaou Digwener Disadorn\nnedelia ponedelnik vtornik sriada chetvartak petak sabota\nsing_kei_yaht sing_kei_yat sing_kei_yee sing_kei_saam sing_kei_sie sing_kei_ng sing_kei_luk\nDiumenge Dilluns Dimarts Dimecres Dijous Divendres Dissabte\nDzeenkk-eh Dzeehn_kk-ehreh Dzeehn_kk-ehreh_nah_kay_dzeeneh Tah_neesee_dzeehn_neh Deehn_ghee_dzee-neh Tl-oowey_tts-el_dehlee Dzeentt-ahzee\ndy_Sul dy_Lun dy_Meurth dy_Mergher dy_You dy_Gwener dy_Sadorn\nDimanch Lendi Madi Mekredi Jedi Vandredi Samdi\nnedjelja ponedjeljak utorak srijeda cxetvrtak petak subota\nnede^le ponde^li utery str^eda c^tvrtek patek sobota\nSondee Mondee Tiisiday Walansedee TOOsedee Feraadee Satadee\ns0ndag mandag tirsdag onsdag torsdag fredag l0rdag\nzondag maandag dinsdag woensdag donderdag vrijdag zaterdag\nDiman^co Lundo Mardo Merkredo ^Jaudo Vendredo Sabato\npUhapaev esmaspaev teisipaev kolmapaev neljapaev reede laupaev\n\nDiu_prima Diu_sequima Diu_tritima Diu_quartima Diu_quintima Diu_sextima Diu_sabbata\nsunnudagur manadagur tysdaguy mikudagur hosdagur friggjadagur leygardagur\nYek_Sham'beh Do_Sham'beh Seh_Sham'beh Cha'har_Sham'beh Panj_Sham'beh Jom'eh Sham'beh\nsunnuntai maanantai tiistai keskiviiko torsktai perjantai lauantai\ndimanche lundi mardi mercredi jeudi vendredi samedi\nSnein Moandei Tiisdei Woansdei Tonersdei Freed Sneon\nDomingo Segunda_feira Martes Mercores Joves Venres Sabado\nk'vira orshabati samshabati otkhshabati khutshabati p'arask'evi shabati\nSonntag Montag Dienstag Mittwoch Donnerstag Freitag Samstag\nKiriaki' Defte'ra Tri'ti Teta'rti Pe'mpti Paraskebi' Sa'bato\nravivaar somvaar mangalvaar budhvaar guruvaar shukravaar shanivaar\npopule po`akahi po`alua po`akolu po`aha po`alima po`aono\nYom_rishon Yom_sheni Yom_shlishi Yom_revi'i Yom_chamishi Yom_shishi Shabat\nravivara somavar mangalavar budhavara brahaspativar shukravara shanivar\nvasarnap hetfo kedd szerda csutortok pentek szombat\nSunnudagur Manudagur +ridjudagur Midvikudagar Fimmtudagur FOstudagur Laugardagur\nsundio lundio mardio merkurdio jovdio venerdio saturdio\nMinggu Senin Selasa Rabu Kamis Jumat Sabtu\nDominica Lunedi Martedi Mercuridi Jovedi Venerdi Sabbato\nDe_Domhnaigh De_Luain De_Mairt De_Ceadaoin De_ardaoin De_hAoine De_Sathairn\ndomenica lunedi martedi mercoledi giovedi venerdi sabato\nNichiyou_bi Getzuyou_bi Kayou_bi Suiyou_bi Mokuyou_bi Kin'you_bi Doyou_bi\nIl-yo-il Wol-yo-il Hwa-yo-il Su-yo-il Mok-yo-il Kum-yo-il To-yo-il\nDies_Dominica Dies_Lunae Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Saturni\nsve-tdien pirmdien otrdien tresvdien ceturtdien piektdien sestdien\nSekmadienis Pirmadienis Antradienis Trec^iadienis Ketvirtadienis Penktadienis S^es^tadienis\nWangu Kazooba Walumbe Mukasa Kiwanuka Nnagawonye Wamunyi\nxing-_qi-_ri xing-_qi-_yi-. xing-_qi-_er xing-_qi-_san-. xing-_qi-_si xing-_qi-_wuv. xing-_qi-_liu\nJedoonee Jelune Jemayrt Jecrean Jardaim Jeheiney Jesam\nJabot Manre Juje Wonje Taije Balaire Jarere\ngeminrongo minomishi martes mierkoles misheushi bernashi mishabaro\nAhad Isnin Selasa Rabu Khamis Jumaat Sabtu\nsphndag mandag tirsdag onsdag torsdag fredag lphrdag\nlo_dimenge lo_diluns lo_dimarc lo_dimercres lo_dijous lo_divendres lo_dissabte\ndjadomingo djaluna djamars djarason djaweps djabierna djasabra\nNiedziela Poniedzial/ek Wtorek S,roda Czwartek Pia,tek Sobota\nDomingo segunda-feire terca-feire quarta-feire quinta-feire sexta-feira sabado\nDomingo Lunes martes Miercoles Jueves Viernes Sabado\nDuminica Luni Mart'i Miercuri Joi Vineri Sambata\nvoskresenie ponedelnik vtornik sreda chetverg pyatnitsa subbota\nSunday Di-luain Di-mairt Di-ciadain Di-ardaoin Di-haoine Di-sathurne\nnedjelja ponedjeljak utorak sreda cxetvrtak petak subota\nSontaha Mmantaha Labobedi Laboraro Labone Labohlano Moqebelo\nIridha- Sandhudha- Anga.haruwa-dha- Badha-dha- Brahaspa.thindha- Sikura-dha- Sena.sura-dha-\nnedel^a pondelok utorok streda s^tvrtok piatok sobota\nNedelja Ponedeljek Torek Sreda Cxetrtek Petek Sobota\ndomingo lunes martes miercoles jueves viernes sabado\nsonde mundey tude-wroko dride-wroko fode-wroko freyda Saturday\nJumapili Jumatatu Jumanne Jumatano Alhamisi Ijumaa Jumamosi\nsondag mandag tisdag onsdag torsdag fredag lordag\nLinggo Lunes Martes Miyerkoles Huwebes Biyernes Sabado\nLe-pai-jit Pai-it Pai-ji Pai-san Pai-si Pai-gO. Pai-lak\nwan-ar-tit wan-tjan wan-ang-kaan wan-phoet wan-pha-ru-hat-sa-boh-die wan-sook wan-sao\nTshipi Mosupologo Labobedi Laboraro Labone Labotlhano Matlhatso\nPazar Pazartesi Sali Car,samba Per,sembe Cuma Cumartesi\nnedilya ponedilok vivtorok sereda chetver pyatnytsya subota\nChu?_Nha.t Thu*_Hai Thu*_Ba Thu*_Tu* Thu*_Na'm Thu*_Sau Thu*_Ba?y\ndydd_Sul dyds_Llun dydd_Mawrth dyds_Mercher dydd_Iau dydd_Gwener dyds_Sadwrn\nDibeer Altine Talaata Allarba Al_xebes Aljuma Gaaw\niCawa uMvulo uLwesibini uLwesithathu uLuwesine uLwesihlanu uMgqibelo\nzuntik montik dinstik mitvokh donershtik fraytik shabes\niSonto uMsombuluko uLwesibili uLwesithathu uLwesine uLwesihlanu uMgqibelo\nDies_Dominica Dies_Lunae Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Saturni\nBazar_gUnU Bazar_aertaesi Caers,aenbae_axs,amo Caers,aenbae_gUnU CUmae_axs,amo CUmae_gUnU CUmae_Senbae\nSun Moon Mars Mercury Jove Venus Saturn\nzondag maandag dinsdag woensdag donderdag vrijdag zaterdag\nKoseEraa GyoOraa BenEraa Kuoraa YOwaaraa FeEraa Memenaa\nSonntag Montag Dienstag Mittwoch Donnerstag Freitag Sonnabend\nDomingo Luns Terza_feira Corta_feira Xoves Venres Sabado\nDies_Solis Dies_Lunae Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Sabbatum\nxing-_qi-_tian xing-_qi-_yi-. xing-_qi-_er xing-_qi-_san-. xing-_qi-_si xing-_qi-_wuv. xing-_qi-_liu\ndjadomingu djaluna djamars djarason djaweps djabierne djasabra\nKillachau Atichau Quoyllurchau Illapachau Chaskachau Kuychichau Intichau\n\n''Caveat:   The list (above) most surely contains errors (or, at the least, differences) of what the actual (or true) names for the days-of-the-week.''\n\n\nTo make this Rosetta Code task page as small as possible, if processing the complete list, read the days-of-the-week from a file (that is created from the above list).\n\n\nNotes concerning the above list of words\n::*   each line has a list of days-of-the-week for a language, separated by at least one blank\n::*   the words on each line happen to be in order, from Sunday --> Saturday\n::*   most lines have words in mixed case and some have all manner of accented words and other characters\n::*   some words were translated to the nearest character that was available to ''code page''   '''437'''\n::*   the characters in the words are not restricted except that they may not have imbedded blanks\n::*   for this example, the use of an underscore ('''_''') was used to indicate a blank in a word\n\n\n;Task:\n::*   The list of words   (days of the week)   needn't be verified/validated.\n::*   Write a function to find the (numeric) minimum length abbreviation for each line that would make abbreviations unique.\n::*   A blank line   (or a null line)   should return a null string.\n::*   Process and show the output for at least the first '''five''' lines of the file.\n::*   Show all output here.\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace Abbreviations {\n    class Program {\n        static void Main(string[] args) {\n            string[] lines = System.IO.File.ReadAllLines(\"days_of_week.txt\");\n            int i = 0;\n\n            foreach (string line in lines) {\n                i++;\n                if (line.Length > 0) {\n                    var days = line.Split();\n                    if (days.Length != 7) {\n                        throw new Exception(\"There aren't 7 days in line \" + i);\n                    }\n\n                    Dictionary<string, int> temp = new Dictionary<string, int>();\n                    foreach (string day in days) {\n                        if (temp.ContainsKey(day)) {\n                            Console.WriteLine(\" \u221e  {0}\", line);\n                            continue;\n                        }\n                        temp.Add(day, 1);\n                    }\n\n                    int len = 1;\n                    while (true) {\n                        temp.Clear();\n                        foreach(string day in days) {\n                            string key;\n                            if (len < day.Length) {\n                                key = day.Substring(0, len);\n                            } else {\n                                key = day;\n                            }\n                            if (temp.ContainsKey(key)) {\n                                break;\n                            }\n                            temp.Add(key, 1);\n                        }\n                        if (temp.Count == 7) {\n                            Console.WriteLine(\"{0,2:D}  {1}\", len, line);\n                            break;\n                        }\n                        len++;\n                    }\n                }\n            }\n        }\n    }\n}"}
{"title": "Abundant odd numbers", "language": "C sharp|C#", "task": "An Abundant number is a number '''n''' for which the   ''sum of divisors''   '''s(n) > 2n''',\nor,   equivalently,   the   ''sum of proper divisors''   (or aliquot sum)       '''s(n) > n'''.\n\n\n;E.G.:\n'''12'''   is abundant, it has the proper divisors     '''1,2,3,4 & 6'''     which sum to   '''16'''   ( > '''12''' or '''n'''); \n       or alternately,   has the sigma sum of   '''1,2,3,4,6 & 12'''   which sum to   '''28'''   ( > '''24''' or '''2n''').\n\n\nAbundant numbers are common, though '''even''' abundant numbers seem to be much more common than '''odd''' abundant numbers. \n\nTo make things more interesting, this task is specifically about finding   ''odd abundant numbers''.\n\n\n;Task\n*Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.\n*Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.\n*Find and display here: the first abundant odd number greater than one billion (109) and either its proper divisor sum or sigma sum.\n\n\n;References:\n:*   OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)\n:*   American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)\n\n", "solution": "using static System.Console;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic static class AbundantOddNumbers\n{\n    public static void Main() {\n        WriteLine(\"First 25 abundant odd numbers:\");\n        foreach (var x in AbundantNumbers().Take(25)) WriteLine(x.Format());\n        WriteLine();\n        WriteLine($\"The 1000th abundant odd number: {AbundantNumbers().ElementAt(999).Format()}\");\n        WriteLine();\n        WriteLine($\"First abundant odd number > 1b: {AbundantNumbers(1_000_000_001).First().Format()}\");\n    }\n\n    static IEnumerable<(int n, int sum)> AbundantNumbers(int start = 3) =>\n        start.UpBy(2).Select(n => (n, sum: n.DivisorSum())).Where(x => x.sum > x.n);\n\n    static int DivisorSum(this int n) => 3.UpBy(2).TakeWhile(i => i * i <= n).Where(i => n % i == 0)\n        .Select(i => (a:i, b:n/i)).Sum(p => p.a == p.b ? p.a : p.a + p.b) + 1;\n\n    static IEnumerable<int> UpBy(this int n, int step) {\n        for (int i = n; ; i+=step) yield return i;\n    }\n\n    static string Format(this (int n, int sum) pair) => $\"{pair.n:N0} with sum {pair.sum:N0}\";\n}"}
{"title": "Accumulator factory", "language": "C sharp 4.0", "task": "{{requires|Mutable State}}\n\nA problem posed by Paul Graham is that of creating a function that takes a single (numeric) argument and which returns another function that is an accumulator. The returned accumulator function in turn also takes a single numeric argument, and returns the sum of all the numeric values passed in so far to that accumulator (including the initial value passed when the accumulator was created).\n\n\n;Rules:\nThe detailed rules are at http://paulgraham.com/accgensub.html and are reproduced here for simplicity (with additions in ''small italic text'').\n:Before you submit an example, make sure the function\n\n:# Takes a number n and returns a function (lets call it g), that takes a number i, and returns n incremented by the accumulation of i from every call of function g(i).Although these exact function and parameter names need not be used\n:# Works for any numeric type-- i.e. can take both ints and floats and returns functions that can take both ints and floats. (It is not enough simply to convert all input to floats. An accumulator that has only seen integers must return integers.) ''(i.e., if the language doesn't allow for numeric polymorphism, you have to use overloading or something like that)''\n:# Generates functions that return the sum of every number ever passed to them, not just the most recent. ''(This requires a piece of state to hold the accumulated value, which in turn means that pure functional languages can't be used for this task.)''\n:# Returns a real function, meaning something that you can use wherever you could use a function you had defined in the ordinary way in the text of your program. ''(Follow your language's conventions here.)''\n:# Doesn't store the accumulated value or the returned functions in a way that could cause them to be inadvertently modified by other code. ''(No global variables or other such things.)''\n: E.g. if after the example, you added the following code (in a made-up language) ''where the factory function is called foo'':\n:: x = foo(1); \nx(5); \nfoo(3);\nprint x(2.3);\n: It should print 8.3. ''(There is no need to print the form of the accumulator function returned by foo(3); it's not part of the task at all.)''\n\n\n;Task:\nCreate a function that implements the described rules. \n\n\nIt need not handle any special error cases not described above. The simplest way to implement the task as described is typically to use a closure, providing the language supports them.\n\nWhere it is not possible to hold exactly to the constraints above, describe the deviations.\n\n", "solution": "using System;\n\nclass Program\n{\n    static Func<dynamic, dynamic> Foo(dynamic n)\n    {\n        return i => n += i;\n    }\n\n    static void Main(string[] args)\n    {\n        var x = Foo(1);\n        x(5);\n        Foo(3);\n        Console.WriteLine(x(2.3));\n    }\n}"}
{"title": "Amb", "language": "C sharp|C#", "task": "Define and give an example of the Amb operator.\n\nThe Amb operator (short for \"ambiguous\") expresses nondeterminism. This doesn't refer to randomness (as in \"nondeterministic universe\") but is closely related to the term as it is used in automata theory (\"non-deterministic finite automaton\").\n\nThe Amb operator takes a variable number of expressions (or values if that's simpler in the language) and yields a correct one which will satisfy a constraint in some future computation, thereby avoiding failure.\n\nProblems whose solution the Amb operator naturally expresses can be approached with other tools, such as explicit nested iterations over data sets, or with pattern matching. By contrast, the Amb operator appears integrated into the language. Invocations of Amb are not wrapped in any visible loops or other search patterns; they appear to be independent. \n\nEssentially Amb(x, y, z) splits the computation into three possible futures: a future in which the value x is yielded, a future in which the value y is yielded and a future in which the value z is yielded. The future which leads to a successful subsequent computation is chosen. The other \"parallel universes\" somehow go away.   Amb called with no arguments fails.\n\nFor simplicity, one of the domain values usable with Amb may denote failure, if that is convenient. For instance, it is convenient if a Boolean false denotes failure, so that Amb(false) fails, and thus constraints can be expressed using Boolean expressions like Amb(x * y == 8) which unless x and y add to four.\n\nA pseudo-code program which satisfies this constraint might look like:\n\nlet x = Amb(1, 2, 3)\nlet y = Amb(7, 6, 4, 5)\nAmb(x * y = 8)\nprint x, y\n\nThe output is 2 4 because Amb(1, 2, 3) correctly chooses the future in which x has value 2, Amb(7, 6, 4, 5) chooses 4 and consequently Amb(x * y = 8) produces a success.\n\nAlternatively, failure could be represented using strictly Amb():\n\nunless x * y = 8 do Amb()\n\nOr else Amb could take the form of two operators or functions: one for producing values and one for enforcing constraints:\n\nlet x = Ambsel(1, 2, 3)\nlet y = Ambsel(4, 5, 6)\nAmbassert(x * y = 8)\nprint x, y\n\nwhere Ambassert behaves like Amb() if the Boolean expression is false, otherwise it allows the future computation to take place, without yielding any value.\n\nThe task is to somehow implement Amb, and demonstrate it with a program which chooses one word from each of the following four sets of character strings to generate a four-word sentence:\n\n#\"the\" \"that\" \"a\"\n#\"frog\" \"elephant\" \"thing\"\n#\"walked\" \"treaded\" \"grows\"\n#\"slowly\" \"quickly\"\n\nThe constraint to be satisfied is that the last character of each word (other than the last) is the same as the first character of its successor.\n\nThe only successful sentence is \"that thing grows slowly\"; other combinations do not satisfy the constraint and thus fail.\n\nThe goal of this task isn't to simply process the four lists of words with explicit, deterministic program flow such as nested iteration, to trivially demonstrate the correct output. The goal is to implement the Amb operator, or a facsimile thereof that is possible within the language limitations.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\npublic class Amb : IDisposable\n{\n    List<IValueSet> streams = new List<IValueSet>();\n    List<IAssertOrAction> assertsOrActions = new List<IAssertOrAction>();\n    volatile bool stopped = false;\n\n    public IAmbValue<T> DefineValues<T>(params T[] values)\n    {\n        return DefineValueSet(values);\n    }\n\n    public IAmbValue<T> DefineValueSet<T>(IEnumerable<T> values)\n    {\n        ValueSet<T> stream = new ValueSet<T>();\n        stream.Enumerable = values;\n        streams.Add(stream);\n        return stream;\n    }\n\n    public Amb Assert(Func<bool> function)\n    {\n        assertsOrActions.Add(new AmbAssert()\n        {\n            Level = streams.Count,\n            IsValidFunction = function\n        });\n        return this;\n    }\n\n    public Amb Perform(Action action)\n    {\n        assertsOrActions.Add(new AmbAction()\n        {\n            Level = streams.Count,\n            Action = action\n        });\n        return this;\n    }\n\n    public void Stop()\n    {\n        stopped = true;\n    }\n\n    public void Dispose()\n    {\n        RunLevel(0, 0);\n        if (!stopped)\n        {\n            throw new AmbException();\n        }\n    }\n\n    void RunLevel(int level, int actionIndex)\n    {\n        while (actionIndex < assertsOrActions.Count && assertsOrActions[actionIndex].Level <= level)\n        {\n            if (!assertsOrActions[actionIndex].Invoke() || stopped)\n                return;\n            actionIndex++;\n        }\n        if (level < streams.Count)\n        {\n            using (IValueSetIterator iterator = streams[level].CreateIterator())\n            {\n                while (iterator.MoveNext())\n                {\n                    RunLevel(level + 1, actionIndex);\n                }\n            }\n        }\n    }\n\n    interface IValueSet\n    {\n        IValueSetIterator CreateIterator();\n    }\n\n    interface IValueSetIterator : IDisposable\n    {\n        bool MoveNext();\n    }\n\n    interface IAssertOrAction\n    {\n        int Level { get; }\n        bool Invoke();\n    }\n\n    class AmbAssert : IAssertOrAction\n    {\n        internal int Level;\n        internal Func<bool> IsValidFunction;\n\n        int IAssertOrAction.Level { get { return Level; } }\n\n        bool IAssertOrAction.Invoke()\n        {\n            return IsValidFunction();\n        }\n    }\n\n    class AmbAction : IAssertOrAction\n    {\n        internal int Level;\n        internal Action Action;\n\n        int IAssertOrAction.Level { get { return Level; } }\n\n        bool IAssertOrAction.Invoke()\n        {\n            Action(); return true;\n        }\n    }\n\n    class ValueSet<T> : IValueSet, IAmbValue<T>, IValueSetIterator\n    {\n        internal IEnumerable<T> Enumerable;\n        private IEnumerator<T> enumerator;\n\n        public T Value { get { return enumerator.Current; } }\n\n        public IValueSetIterator CreateIterator()\n        {\n            enumerator = Enumerable.GetEnumerator();\n            return this;\n        }\n\n        public bool MoveNext()\n        {\n            return enumerator.MoveNext();\n        }\n\n        public void Dispose()\n        {\n            enumerator.Dispose();\n        }\n    }\n}\n\npublic interface IAmbValue<T>\n{\n    T Value { get; }\n}\n\npublic class AmbException : Exception\n{\n    public AmbException() : base(\"AMB is angry\") { }\n}"}
{"title": "Amb", "language": "C sharp", "task": "Define and give an example of the Amb operator.\n\nThe Amb operator (short for \"ambiguous\") expresses nondeterminism. This doesn't refer to randomness (as in \"nondeterministic universe\") but is closely related to the term as it is used in automata theory (\"non-deterministic finite automaton\").\n\nThe Amb operator takes a variable number of expressions (or values if that's simpler in the language) and yields a correct one which will satisfy a constraint in some future computation, thereby avoiding failure.\n\nProblems whose solution the Amb operator naturally expresses can be approached with other tools, such as explicit nested iterations over data sets, or with pattern matching. By contrast, the Amb operator appears integrated into the language. Invocations of Amb are not wrapped in any visible loops or other search patterns; they appear to be independent. \n\nEssentially Amb(x, y, z) splits the computation into three possible futures: a future in which the value x is yielded, a future in which the value y is yielded and a future in which the value z is yielded. The future which leads to a successful subsequent computation is chosen. The other \"parallel universes\" somehow go away.   Amb called with no arguments fails.\n\nFor simplicity, one of the domain values usable with Amb may denote failure, if that is convenient. For instance, it is convenient if a Boolean false denotes failure, so that Amb(false) fails, and thus constraints can be expressed using Boolean expressions like Amb(x * y == 8) which unless x and y add to four.\n\nA pseudo-code program which satisfies this constraint might look like:\n\nlet x = Amb(1, 2, 3)\nlet y = Amb(7, 6, 4, 5)\nAmb(x * y = 8)\nprint x, y\n\nThe output is 2 4 because Amb(1, 2, 3) correctly chooses the future in which x has value 2, Amb(7, 6, 4, 5) chooses 4 and consequently Amb(x * y = 8) produces a success.\n\nAlternatively, failure could be represented using strictly Amb():\n\nunless x * y = 8 do Amb()\n\nOr else Amb could take the form of two operators or functions: one for producing values and one for enforcing constraints:\n\nlet x = Ambsel(1, 2, 3)\nlet y = Ambsel(4, 5, 6)\nAmbassert(x * y = 8)\nprint x, y\n\nwhere Ambassert behaves like Amb() if the Boolean expression is false, otherwise it allows the future computation to take place, without yielding any value.\n\nThe task is to somehow implement Amb, and demonstrate it with a program which chooses one word from each of the following four sets of character strings to generate a four-word sentence:\n\n#\"the\" \"that\" \"a\"\n#\"frog\" \"elephant\" \"thing\"\n#\"walked\" \"treaded\" \"grows\"\n#\"slowly\" \"quickly\"\n\nThe constraint to be satisfied is that the last character of each word (other than the last) is the same as the first character of its successor.\n\nThe only successful sentence is \"that thing grows slowly\"; other combinations do not satisfy the constraint and thus fail.\n\nThe goal of this task isn't to simply process the four lists of words with explicit, deterministic program flow such as nested iteration, to trivially demonstrate the correct output. The goal is to implement the Amb operator, or a facsimile thereof that is possible within the language limitations.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace Amb {\n    public interface IValue<T> {\n        T Value { get; }\n        string ToString();\n    }\n\n    public sealed class Amb {\n        public IValue<T> Choose<T>(params T[] choices) {\n            var array = new ChoiceArray<T> { Values = choices };\n            _choices.Add(array);\n            return array;\n        }\n\n        public void Require(Func<bool> predicate) =>\n            _constraints.Add(new Constraint { Predicate = predicate, AppliesForItems = _choices.Count });\n\n        public bool Disambiguate() => Disambiguate(0, 0);\n\n        interface IChoices {\n            int Length { get; }\n            int Index { get; set; }\n        }\n\n        interface IConstraint {\n            int AppliesForItems { get; }\n            bool Invoke();\n        }\n\n        readonly List<IChoices> _choices = new();\n        readonly List<IConstraint> _constraints = new();\n\n        bool Disambiguate(int choicesTracked, int constraintIdx) {\n            while (constraintIdx < _constraints.Count && _constraints[constraintIdx].AppliesForItems <= choicesTracked) {\n                if (!_constraints[constraintIdx].Invoke())\n                    return false;\n                constraintIdx++;\n            }\n\n            if (choicesTracked == _choices.Count)\n                return true;\n\n            for (var i = 0; i < _choices[choicesTracked].Length; i++) {\n                _choices[choicesTracked].Index = i;\n                if (Disambiguate(choicesTracked + 1, constraintIdx))\n                    return true;\n            }\n            return false;\n        }\n\n        class Constraint : IConstraint {\n            internal Func<bool> Predicate;\n\n            public int AppliesForItems { get; set; }  \n\n            public bool Invoke() => Predicate?.Invoke() ?? default;\n        }\n\n        class ChoiceArray<T> : IChoices, IValue<T> {\n            internal T[] Values;\n\n            public int Index { get; set; }\n\n            public T Value => Values[Index];\n\n            public int Length => Values.Length;\n\n            public override string ToString() => Value.ToString();\n        }\n    }\n}\n\n\n"}
{"title": "Anagrams/Deranged anagrams", "language": "C sharp 6", "task": "Two or more words are said to be anagrams if they have the same characters, but in a different order. \n\nBy analogy with derangements we define a  ''deranged anagram'' as two words with the same characters, but in which the same character does ''not'' appear in the same position in both words.\n\n;Task\n\nUse the word list at unixdict to find and display the longest deranged anagram. \n\n\n;Related\n* [[Permutations/Derangements]]\n* Best shuffle\n\n{{Related tasks/Word plays}}\n\n\n\n", "solution": "public static void Main()\n{\n    var lookupTable = File.ReadLines(\"unixdict.txt\").ToLookup(line => AnagramKey(line));\n    var query = from a in lookupTable\n        orderby a.Key.Length descending\n        let deranged = FindDeranged(a)\n        where deranged != null\n        select deranged[0] + \" \" + deranged[1];\n    Console.WriteLine(query.FirstOrDefault());\n}\n\t\nstatic string AnagramKey(string word) => new string(word.OrderBy(c => c).ToArray());\n\t\nstatic string[] FindDeranged(IEnumerable<string> anagrams) => (\n    from first in anagrams\n    from second in anagrams\n    where !second.Equals(first)\n        && Enumerable.Range(0, first.Length).All(i => first[i] != second[i])\n    select new [] { first, second })\n    .FirstOrDefault();"}
{"title": "Angle difference between two bearings", "language": "C sharp|C#", "task": "Finding the angle between two bearings is often confusing.[https://stackoverflow.com/questions/16180595/find-the-angle-between-two-bearings]\n\n\n;Task:\nFind the angle which is the result of the subtraction '''b2 - b1''', where '''b1''' and '''b2''' are the bearings. \n\nInput bearings are expressed in the range   '''-180'''   to   '''+180'''   degrees. \nThe  result  is also expressed in the range   '''-180'''   to   '''+180'''   degrees. \n\n\nCompute the angle for the following pairs:\n*  20 degrees ('''b1''') and 45 degrees ('''b2''')\n* -45 and  45\n* -85 and  90\n* -95 and  90\n* -45 and 125\n* -45 and 145\n*  29.4803 and  -88.6381\n* -78.3251 and -159.036\n\n\n;Optional extra:  \nAllow the input bearings to be any (finite) value. \n\n\n;Test cases:\n*  -70099.74233810938   and   29840.67437876723\n* -165313.6666297357    and   33693.9894517456\n*    1174.8380510598456 and -154146.66490124757\n*   60175.77306795546   and   42213.07192354373\n\n", "solution": "using System;\n\nnamespace Angle_difference_between_two_bearings\n{\n\tclass Program\n\t{\n\t\tpublic static void Main(string[] args)\n\t\t{\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.WriteLine(\"Hello World!\");\n\t\t\tConsole.WriteLine();\n\t\t\t\n\t\t\t// Calculate standard test cases\n\t\t\tConsole.WriteLine(Delta_Bearing( 20M,45));\n\t\t\tConsole.WriteLine(Delta_Bearing(-45M,45M));\n\t\t\tConsole.WriteLine(Delta_Bearing(-85M,90M));\n\t\t\tConsole.WriteLine(Delta_Bearing(-95M,90M));\n\t\t\tConsole.WriteLine(Delta_Bearing(-45M,125M));\n\t\t\tConsole.WriteLine(Delta_Bearing(-45M,145M));\n\t\t\tConsole.WriteLine(Delta_Bearing( 29.4803M,-88.6381M));\n\t\t\tConsole.WriteLine(Delta_Bearing(-78.3251M, -159.036M));\n\t\t\t\n\t\t\t// Calculate optional test cases\n\t\t\tConsole.WriteLine(Delta_Bearing(-70099.74233810938M,   29840.67437876723M));\n\t\t\tConsole.WriteLine(Delta_Bearing(-165313.6666297357M,   33693.9894517456M));\n\t\t\tConsole.WriteLine(Delta_Bearing( 1174.8380510598456M, -154146.66490124757M));\n\t\t\tConsole.WriteLine(Delta_Bearing( 60175.77306795546M,   42213.07192354373M));\n\t\t\t\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.Write(\"Press any key to continue . . . \");\n\t\t\tConsole.ReadKey(true);\n\t\t}\n\t\t\n\t\tstatic decimal Delta_Bearing(decimal b1, decimal b2)\n\t\t{\n\t\t\t/*\n\t\t\t * Optimal solution\n\t\t\t *\n\t\t\tdecimal d = 0;\n\t\t\t\n\t\t\td = (b2-b1)%360;\n\t\t\t\n\t\t\tif(d>180)\n\t\t\t\td -= 360;\n\t\t\telse if(d<-180)\n\t\t\t\td += 360;\n\t\t\t\n\t\t\treturn d;\n\t\t\t *\n\t\t\t * \n\t\t\t */\n\t\t\t\n\t\t\t\n\t\t\t//\n\t\t\t//\n\t\t\t//\n\t\t\tdecimal d = 0;\n\t\t\t\n\t\t\t// Convert bearing to W.C.B\n\t\t\tif(b1<0)\n\t\t\t\tb1 += 360;\n\t\t\tif(b2<0)\n\t\t\t\tb2 += 360;\n\t\t\t\n\t\t\t///Calculate delta bearing\n\t\t\t//and\n\t\t\t//Convert result value to Q.B.\n\t\t\td = (b2 - b1)%360;\n\t\t\t\n\t\t\tif(d>180)\n\t\t\t\td -= 360;\n\t\t\telse if(d<-180)\n\t\t\t\td += 360;\n\t\t\t\n\t\t\treturn d;\n\t\t\t\n\t\t\t//\n\t\t\t//\n\t\t\t//\n\t\t}\n\t}\n}"}
{"title": "Anti-primes", "language": "C sharp 7", "task": "The anti-primes \n(or highly composite numbers, sequence A002182 in the OEIS) \nare the natural numbers with more factors than any smaller than itself.\n\n\n;Task:\nGenerate and show here, the first twenty anti-primes.\n\n\n;Related tasks:\n:*   [[Factors of an integer]]\n:*   [[Sieve of Eratosthenes]]\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\t\t\t\t\t\npublic static class Program\n{\n    public static void Main() =>\n        Console.WriteLine(string.Join(\" \", FindAntiPrimes().Take(20)));\n\t\n    static IEnumerable<int> FindAntiPrimes() {\n        int max = 0;\n        for (int i = 1; ; i++) {\n            int divisors = CountDivisors(i);\n            if (divisors > max) {\n                max = divisors;\n                yield return i;\n            }\n        }\n\t\n        int CountDivisors(int n) => Enumerable.Range(1, n / 2).Count(i => n % i == 0) + 1;\n    }\n}"}
{"title": "Apply a digital filter (direct form II transposed)", "language": "C sharp|C# from Java", "task": "Digital filters are used to apply a mathematical operation to a sampled signal. One of the common formulations is the \"direct form II transposed\" which can represent both infinite impulse response (IIR) and finite impulse response (FIR) filters, as well as being more numerically stable than other forms. [https://ccrma.stanford.edu/~jos/fp/Transposed_Direct_Forms.html]\n\n;Task:\n\nFilter a signal using an order 3 low-pass Butterworth filter. The coefficients for the filter are a=[1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17] and b = [0.16666667, 0.5, 0.5, 0.16666667]\n\nThe signal that needs filtering is the following vector: [-0.917843918645, 0.141984778794, 1.20536903482, 0.190286794412, -0.662370894973, -1.00700480494, -0.404707073677 ,0.800482325044, 0.743500089861, 1.01090520172, 0.741527555207, 0.277841675195, 0.400833448236, -0.2085993586, -0.172842103641, -0.134316096293, 0.0259303398477, 0.490105989562, 0.549391221511, 0.9047198589]\n\n;See also:\n[Wikipedia on Butterworth filters]\n\n\n", "solution": "using System;\n\nnamespace ApplyDigitalFilter {\n    class Program {\n        private static double[] Filter(double[] a, double[] b, double[] signal) {\n            double[] result = new double[signal.Length];\n            for (int i = 0; i < signal.Length; ++i) {\n                double tmp = 0.0;\n                for (int j = 0; j < b.Length; ++j) {\n                    if (i - j < 0) continue;\n                    tmp += b[j] * signal[i - j];\n                }\n                for (int j = 1; j < a.Length; ++j) {\n                    if (i - j < 0) continue;\n                    tmp -= a[j] * result[i - j];\n                }\n                tmp /= a[0];\n                result[i] = tmp;\n            }\n            return result;\n        }\n\n        static void Main(string[] args) {\n            double[] a = new double[] { 1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17 };\n            double[] b = new double[] { 0.16666667, 0.5, 0.5, 0.16666667 };\n\n            double[] signal = new double[] {\n                -0.917843918645, 0.141984778794, 1.20536903482, 0.190286794412,\n                -0.662370894973, -1.00700480494, -0.404707073677, 0.800482325044,\n                0.743500089861, 1.01090520172, 0.741527555207, 0.277841675195,\n                0.400833448236, -0.2085993586, -0.172842103641, -0.134316096293,\n                0.0259303398477, 0.490105989562, 0.549391221511, 0.9047198589\n            };\n\n            double[] result = Filter(a, b, signal);\n            for (int i = 0; i < result.Length; ++i) {\n                Console.Write(\"{0,11:F8}\", result[i]);\n                Console.Write((i + 1) % 5 != 0 ? \", \" : \"\\n\");\n            }\n        }\n    }\n}"}
{"title": "Approximate equality", "language": "C sharp|C#", "task": "Sometimes, when testing whether the solution to a task (for example, here on Rosetta Code) is correct, the\ndifference in floating point calculations between different language implementations becomes significant. \n\nFor example, a difference between '''32''' bit and '''64''' bit floating point calculations may appear by \nabout the 8th significant digit in base 10 arithmetic.\n\n\n;Task:\nCreate a function which returns true if two floating point numbers are approximately equal. \n\n\nThe function should allow for differences in the magnitude of numbers, so that, for example, \n'''100000000000000.01'''   may be approximately equal to   '''100000000000000.011''', \neven though   '''100.01'''   is not approximately equal to   '''100.011'''.\n\nIf the language has such a feature in its standard library, this may be used instead of a custom function.\n\nShow the function results with comparisons on the following pairs of values:\n:#     100000000000000.01,                        100000000000000.011       (note: should return ''true'')\n:#     100.01,                                    100.011                                                     (note: should return ''false'')\n:#     10000000000000.001 / 10000.0,   1000000000.0000001000\n:#     0.001,                                     0.0010000001\n:#     0.000000000000000000000101,                0.0\n:#      sqrt(2) * sqrt(2),                    2.0\n:#     -sqrt(2) * sqrt(2),                        -2.0\n:#     3.14159265358979323846,                    3.14159265358979324\n\nAnswers should be true for the first example and false in the second, so that just rounding the numbers to a fixed number of decimals should not be enough. Otherwise answers may vary and still be correct. See the Python code for one type of solution.\n\n\n__TOC__\n\n", "solution": "using System;\n\npublic static class Program\n{\n    public static void Main() {\n        Test(100000000000000.01, 100000000000000.011);\n        Test(100.01, 100.011);\n        Test(10000000000000.001 / 10000.0, 1000000000.0000001000);\n        Test(0.001, 0.0010000001);\n        Test(0.000000000000000000000101, 0.0);\n        Test(Math.Sqrt(2) * Math.Sqrt(2), 2.0);\n        Test(-Math.Sqrt(2) * Math.Sqrt(2), -2.0);\n        Test(3.14159265358979323846, 3.14159265358979324);\n\n        void Test(double a, double b) {\n            const double epsilon = 1e-18;\n            WriteLine($\"{a}, {b} => {a.ApproxEquals(b, epsilon)}\");\n        }\n    }\n\n    public static bool ApproxEquals(this double value, double other, double epsilon) => Math.Abs(value - other) < epsilon;\n}"}
{"title": "Archimedean spiral", "language": "C sharp|C#", "task": "The Archimedean spiral is a spiral named after the Greek mathematician Archimedes. \n\n\nAn Archimedean spiral can be described by the equation:\n\n:\\, r=a+b\\theta\n\nwith real numbers ''a'' and ''b''.\n\n\n;Task\nDraw an Archimedean spiral.\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Drawing;\nusing System.Diagnostics;\nusing System.Drawing.Drawing2D;\n\nclass Program\n{\n    const int width = 380;\n    const int height = 380;\n    static PointF archimedeanPoint(int degrees)\n    {\n        const double a = 1;\n        const double b = 9;\n        double t = degrees * Math.PI / 180;\n        double r = a + b * t;\n        return new PointF { X = (float)(width / 2 + r * Math.Cos(t)), Y = (float)(height / 2 + r * Math.Sin(t)) };\n    }\n\n    static void Main(string[] args)\n    {\n        var bm = new Bitmap(width, height);\n        var g = Graphics.FromImage(bm);\n        g.SmoothingMode = SmoothingMode.AntiAlias;\n        g.FillRectangle(new SolidBrush(Color.White), new Rectangle { X = 0, Y = 0, Width = width, Height = height });\n        var pen = new Pen(Color.OrangeRed, 1.5f);\n\n        var spiral = Enumerable.Range(0, 360 * 3).AsParallel().AsOrdered().Select(archimedeanPoint);\n        var p0 = new PointF(width / 2, height / 2);\n        foreach (var p1 in spiral)\n        {\n            g.DrawLine(pen, p0, p1);\n            p0 = p1;\n        }\n        g.Save(); // is this really necessary ?\n        bm.Save(\"archimedes-csharp.png\");\n        Process.Start(\"archimedes-csharp.png\"); // Launches default photo viewing app\n    }\n}\n"}
{"title": "Arithmetic-geometric mean", "language": "C sharp|C#", "task": "{{wikipedia|Arithmetic-geometric mean}}\n\n\n;Task:\nWrite a function to compute the arithmetic-geometric mean of two numbers.\n\n\nThe arithmetic-geometric mean of two numbers can be (usefully) denoted as \\mathrm{agm}(a,g), and is equal to the limit of the sequence:\n: a_0 = a; \\qquad g_0 = g\n: a_{n+1} = \\tfrac{1}{2}(a_n + g_n); \\quad g_{n+1} = \\sqrt{a_n g_n}.\nSince the limit of a_n-g_n tends (rapidly) to zero with iterations, this is an efficient method.\n\nDemonstrate the function by calculating:\n:\\mathrm{agm}(1,1/\\sqrt{2})\n \n\n;Also see:\n*   mathworld.wolfram.com/Arithmetic-Geometric Mean\n\n", "solution": "namespace RosettaCode.ArithmeticGeometricMean\n{\n    using System;\n    using System.Collections.Generic;\n    using System.Globalization;\n\n    internal static class Program\n    {\n        private static double ArithmeticGeometricMean(double number,\n                                                      double otherNumber,\n                                                      IEqualityComparer<double>\n                                                          comparer)\n        {\n            return comparer.Equals(number, otherNumber)\n                       ? number\n                       : ArithmeticGeometricMean(\n                           ArithmeticMean(number, otherNumber),\n                           GeometricMean(number, otherNumber), comparer);\n        }\n\n        private static double ArithmeticMean(double number, double otherNumber)\n        {\n            return 0.5 * (number + otherNumber);\n        }\n\n        private static double GeometricMean(double number, double otherNumber)\n        {\n            return Math.Sqrt(number * otherNumber);\n        }\n\n        private static void Main()\n        {\n            Console.WriteLine(\n                ArithmeticGeometricMean(1, 0.5 * Math.Sqrt(2),\n                                        new RelativeDifferenceComparer(1e-5)).\n                    ToString(CultureInfo.InvariantCulture));\n        }\n\n        private class RelativeDifferenceComparer : IEqualityComparer<double>\n        {\n            private readonly double _maximumRelativeDifference;\n\n            internal RelativeDifferenceComparer(double maximumRelativeDifference)\n            {\n                _maximumRelativeDifference = maximumRelativeDifference;\n            }\n\n            public bool Equals(double number, double otherNumber)\n            {\n                return RelativeDifference(number, otherNumber) <=\n                       _maximumRelativeDifference;\n            }\n\n            public int GetHashCode(double number)\n            {\n                return number.GetHashCode();\n            }\n\n            private static double RelativeDifference(double number,\n                                                     double otherNumber)\n            {\n                return AbsoluteDifference(number, otherNumber) /\n                       Norm(number, otherNumber);\n            }\n\n            private static double AbsoluteDifference(double number,\n                                                     double otherNumber)\n            {\n                return Math.Abs(number - otherNumber);\n            }\n\n            private static double Norm(double number, double otherNumber)\n            {\n                return 0.5 * (Math.Abs(number) + Math.Abs(otherNumber));\n            }\n        }\n    }\n}"}
{"title": "Array length", "language": "C sharp|C#", "task": "Determine the amount of elements in an array.\n\n\nAs an example use an array holding the strings 'apple' and 'orange'.\n\n\n\n", "solution": "var fruit = new[] { \"apple\", \"orange\" };\nvar fruit = new string[] { \"apple\", \"orange\" };\nstring[] fruit = new[] { \"apple\", \"orange\" };\nstring[] fruit = new string[] { \"apple\", \"orange\" };\nstring[] fruit = { \"apple\", \"orange\" };\n"}
{"title": "Ascending primes", "language": "C# from PHP", "task": "Generate and show all primes with strictly ascending decimal digits.\n\nAside: Try solving without peeking at existing solutions. I had a weird idea for generating\na prime sieve faster, which needless to say didn't pan out. The solution may be p(r)etty trivial\nbut generating them quickly is at least mildly interesting.\nTip: filtering all 7,027,260 primes below 123,456,789 probably won't kill you, but there is\nat least one significantly better and much faster way, needing a mere 511 odd/prime tests.\n\n\n;See also\n;* OEIS:A052015 - Primes with distinct digits in ascending order\n\n\n;Related:\n*[[Primes with digits in nondecreasing order]] (infinite series allowing duplicate digits, whereas this isn't and doesn't)\n*[[Pandigital prime]] (whereas this is the smallest, with gaps in the used digits being permitted)\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace ascendingprimes\n{\n    class Program\n    {\n        static bool isPrime(uint n)\n        {\n            if (n == 2)\n                return true;\n            if (n == 1 || n % 2 = 0)\n                return false;\n            uint root = (uint)Math.Sqrt(n);\n            for (uint k = 3; k <= root; k += 2)\n                if (n % k == 0)\n                    return false;\n            return true;\n        }\n        static void Main(string[] args)\n        {\n            var queue = new Queue<uint>();\n            var primes = new List<uint>();\n\n            for (uint k = 1; k <= 9; k++)\n                queue.Enqueue(k);\n            while(queue.Count > 0)\n            {\n                uint n = queue.Dequeue();\n                if (isPrime(n))\n                    primes.Add(n);\n                for (uint k = n % 10 + 1; k <= 9; k++)\n                    queue.Enqueue(n * 10 + k);\n            }\n\n            foreach (uint p in primes)\n            {\n                Console.Write(p);\n                Console.Write(\" \");\n            }\n            Console.WriteLine();\n        }\n    }\n}"}
{"title": "Associative array/Merging", "language": "C sharp|C#", "task": "Define two associative arrays, where one represents the following \"base\" data:\n\n::::: {| class=\"wikitable\"\n|+\n| '''Key''' || '''Value'''\n|-\n| \"name\" || \"Rocket Skates\"\n|-\n| \"price\" || 12.75\n|-\n| \"color\" || \"yellow\"\n|}\n\nAnd the other represents \"update\" data:\n\n::::: {| class=\"wikitable\"\n|+\n| '''Key''' || '''Value'''\n|-\n| \"price\" || 15.25\n|-\n| \"color\" || \"red\"\n|-\n| \"year\" || 1974\n|}\n\nMerge these into a new associative array that contains every key found in either of the source ones.  Each key should map to the value in the second (update) table if that exists, or else to the value in the first (base) table.  If possible, do this in a way that does not mutate the original two associative arrays.  Obviously this should be done in a way that would work for any data, not just the specific data given here, but in this example the result should be:\n\n::::: {| class=\"wikitable\"\n|+\n| '''Key''' || '''Value'''\n|-\n| \"name\" || \"Rocket Skates\"\n|-\n| \"price\" || 15.25\n|-\n| \"color\" || \"red\"\n|-\n| \"year\" || 1974\n|}\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic class Program\n{\n    public static void Main() {\n        var baseData = new Dictionary<string, object> {\n            [\"name\"] = \"Rocket Skates\",\n            [\"price\"] = 12.75,\n            [\"color\"] = \"yellow\"\n        };\n        var updateData = new Dictionary<string, object> {\n            [\"price\"] = 15.25,\n            [\"color\"] = \"red\",\n            [\"year\"] = 1974\n        };\n        var mergedData = new Dictionary<string, object>();\n        foreach (var entry in baseData.Concat(updateData)) {\n            mergedData[entry.Key] = entry.Value;\n        }\n        foreach (var entry in mergedData) {\n            Console.WriteLine(entry);\n        }\n   }\n}"}
{"title": "Attractive numbers", "language": "C sharp|C# from D", "task": "A number is an   ''attractive number''   if the number of its prime factors (whether distinct or not) is also prime.\n\n\n;Example:\nThe number   '''20''',   whose prime decomposition is   '''2 x 2 x 5''',   is an   ''attractive number''   because the number of its prime factors   ('''3''')   is also prime.\n\n\n;Task:\nShow sequence items up to   '''120'''.\n\n\n;Reference:\n:*   The OEIS entry:   A063989: Numbers with a prime number of prime divisors.\n\n", "solution": "using System;\n\nnamespace AttractiveNumbers {\n    class Program {\n        const int MAX = 120;\n\n        static bool IsPrime(int n) {\n            if (n < 2) return false;\n            if (n % 2 == 0) return n == 2;\n            if (n % 3 == 0) return n == 3;\n            int d = 5;\n            while (d * d <= n) {\n                if (n % d == 0) return false;\n                d += 2;\n                if (n % d == 0) return false;\n                d += 4;\n            }\n            return true;\n        }\n\n        static int PrimeFactorCount(int n) {\n            if (n == 1) return 0;\n            if (IsPrime(n)) return 1;\n            int count = 0;\n            int f = 2;\n            while (true) {\n                if (n % f == 0) {\n                    count++;\n                    n /= f;\n                    if (n == 1) return count;\n                    if (IsPrime(n)) f = n;\n                } else if (f >= 3) {\n                    f += 2;\n                } else {\n                    f = 3;\n                }\n            }\n        }\n\n        static void Main(string[] args) {\n            Console.WriteLine(\"The attractive numbers up to and including {0} are:\", MAX);\n            int i = 1;\n            int count = 0;\n            while (i <= MAX) {\n                int n = PrimeFactorCount(i);\n                if (IsPrime(n)) {\n                    Console.Write(\"{0,4}\", i);\n                    if (++count % 20 == 0) Console.WriteLine();\n                }\n                ++i;\n            }\n            Console.WriteLine();\n        }\n    }\n}"}
{"title": "Average loop length", "language": "C sharp|C# from Java", "task": "Let f be a uniformly-randomly chosen mapping from the numbers 1..N to the numbers 1..N (note: not necessarily a permutation of 1..N; the mapping could produce a number in more than one way or not at all). At some point, the sequence 1, f(1), f(f(1))... will contain a repetition, a number that occurring for the second time in the sequence.\n\n\n;Task:\nWrite a program or a script that estimates, for each N, the average length until the first such repetition.\n\nAlso calculate this expected length using an analytical formula, and optionally compare the simulated result with the theoretical one.\n\n\nThis problem comes from the end of Donald Knuth's Christmas tree lecture 2011.\n\nExample of expected output:\n\n N    average    analytical    (error)\n===  =========  ============  =========\n  1     1.0000        1.0000  (  0.00%)\n  2     1.4992        1.5000  (  0.05%)\n  3     1.8784        1.8889  (  0.56%)\n  4     2.2316        2.2188  (  0.58%)\n  5     2.4982        2.5104  (  0.49%)\n  6     2.7897        2.7747  (  0.54%)\n  7     3.0153        3.0181  (  0.09%)\n  8     3.2429        3.2450  (  0.07%)\n  9     3.4536        3.4583  (  0.14%)\n 10     3.6649        3.6602  (  0.13%)\n 11     3.8091        3.8524  (  1.12%)\n 12     3.9986        4.0361  (  0.93%)\n 13     4.2074        4.2123  (  0.12%)\n 14     4.3711        4.3820  (  0.25%)\n 15     4.5275        4.5458  (  0.40%)\n 16     4.6755        4.7043  (  0.61%)\n 17     4.8877        4.8579  (  0.61%)\n 18     4.9951        5.0071  (  0.24%)\n 19     5.1312        5.1522  (  0.41%)\n 20     5.2699        5.2936  (  0.45%)\n\n", "solution": "public class AverageLoopLength {\n\tprivate static int N = 100000;\n\t\n\tprivate static double analytical(int n) {\n\t\tdouble[] factorial = new double[n + 1];\n\t\tdouble[] powers = new double[n + 1];\n\t\tpowers[0] = 1.0;\n\t\tfactorial[0] = 1.0;\n\t\tfor (int i = 1; i <= n; i++) {\n\t\t\tfactorial[i] = factorial[i - 1] * i;\n\t\t\tpowers[i] = powers[i - 1] * n;\n\t\t}\n\t\tdouble sum = 0;\n\t\t\n\t\tfor (int i = 1; i <= n; i++) {\n\t\t\tsum += factorial[n] / factorial[n - i] / powers[i];\n\t\t}\n\t\treturn sum;\n\t}\n\n\tprivate static double average(int n) {\n\t\tRandom rnd = new Random();\n\t\tdouble sum = 0.0;\n\t\tfor (int a = 0; a < N; a++) {\n\t\t\tint[] random = new int[n];\n\t\t\tfor (int i = 0; i < n; i++) {\n\t\t\t\trandom[i] = rnd.Next(n);\n\t\t\t}\n\t\t\tvar seen = new HashSet<double>(n);\n\t\t\tint current = 0;\n\t\t\tint length = 0;\n\t\t\twhile (seen.Add(current)) {\n\t\t\t\tlength++;\n\t\t\t\tcurrent = random[current];\n\t\t\t}\n\t\t\tsum += length;\n\t\t}\n\t\treturn sum / N;\n\t}\n\t\n\tpublic static void Main(string[] args) {\n\tConsole.WriteLine(\" N    average    analytical    (error)\");\n\tConsole.WriteLine(\"===  =========  ============  =========\");\n\t\tfor (int i = 1; i <= 20; i++) {\n\t\t\tvar average = AverageLoopLength.average(i);\n\t\t\tvar analytical = AverageLoopLength.analytical(i);\n\t\t\tConsole.WriteLine(\"{0,3} {1,10:N4} {2,13:N4}  {3,8:N2}%\", i, average, analytical, (analytical - average) / analytical * 100);\n\t\t}\n\t}\n}\n"}
{"title": "Averages/Mean angle", "language": "C sharp|C#", "task": "{{Related tasks/Statistical measures}}\n\n\n", "solution": "using System;\nusing System.Linq;\nusing static System.Math;\nclass Program\n{\n    static double MeanAngle(double[] angles)\n    {\n        var x = angles.Sum(a => Cos(a * PI / 180)) / angles.Length;\n        var y = angles.Sum(a => Sin(a * PI / 180)) / angles.Length;\n        return Atan2(y, x) * 180 / PI;\n    }\n    static void Main()\n    {\n        Action<double[]> printMean = x => Console.WriteLine(\"{0:0.###}\", MeanAngle(x));\n        printMean(new double[] { 350, 10 });\n        printMean(new double[] { 90, 180, 270, 360 });\n        printMean(new double[] { 10, 20, 30 });\n    }\n}"}
{"title": "Averages/Pythagorean means", "language": "C sharp|C#", "task": "{{Related tasks/Statistical measures}}\n\n\n", "solution": "The standard Linq extension method <tt>Average</tt> provides arithmetic mean. This example adds two more extension methods for the geometric and harmonic means.\n\n"}
{"title": "Averages/Pythagorean means", "language": "C sharp", "task": "{{Related tasks/Statistical measures}}\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics;\nusing System.Linq;\n\nnamespace PythMean\n{\n    static class Program\n    {\n        static void Main(string[] args) {\n            var nums = from n in Enumerable.Range(1, 10) select (double)n;\n\n            var a = nums.Average();\n            var g = nums.Gmean();\n            var h = nums.Hmean();\n\n            Console.WriteLine(\"Arithmetic mean {0}\", a);\n            Console.WriteLine(\"Geometric mean  {0}\", g);\n            Console.WriteLine(\"Harmonic mean   {0}\", h);\n\n            Debug.Assert(a >= g && g >= h);\n        }\n\n        // Geometric mean extension method.\n        static double Gmean(this IEnumerable<double> n) {\n            return Math.Pow(n.Aggregate((s, i) => s * i), 1.0 / n.Count());\n        }\n\n        // Harmonic mean extension method.\n        static double Hmean(this IEnumerable<double> n) {\n            return n.Count() / n.Sum(i => 1.0 / i);\n        }\n    }\n}"}
{"title": "Averages/Root mean square", "language": "C sharp|C#", "task": "Task\n\nCompute the   Root mean square   of the numbers 1..10.\n\n\nThe   ''root mean square''   is also known by its initials RMS (or rms), and as the '''quadratic mean'''.\n\nThe RMS is calculated as the mean of the squares of the numbers, square-rooted:\n\n\n::: x_{\\mathrm{rms}} = \\sqrt {{{x_1}^2 + {x_2}^2 + \\cdots + {x_n}^2} \\over n}. \n\n\n;See also\n\n{{Related tasks/Statistical measures}}\n\n\n", "solution": "using System;\n\nnamespace rms\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            int[] x = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };\n            Console.WriteLine(rootMeanSquare(x));\n        }\n\n        private static double rootMeanSquare(int[] x)\n        {            \n            double sum = 0;\n            for (int i = 0; i < x.Length; i++)\n            {\n                sum += (x[i]*x[i]);\n            }\n            return Math.Sqrt(sum / x.Length);\n        }\n    }\n}"}
{"title": "Averages/Root mean square", "language": "C sharp", "task": "Task\n\nCompute the   Root mean square   of the numbers 1..10.\n\n\nThe   ''root mean square''   is also known by its initials RMS (or rms), and as the '''quadratic mean'''.\n\nThe RMS is calculated as the mean of the squares of the numbers, square-rooted:\n\n\n::: x_{\\mathrm{rms}} = \\sqrt {{{x_1}^2 + {x_2}^2 + \\cdots + {x_n}^2} \\over n}. \n\n\n;See also\n\n{{Related tasks/Statistical measures}}\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace rms\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            Console.WriteLine(rootMeanSquare(Enumerable.Range(1, 10)));\n        }\n\n        private static double rootMeanSquare(IEnumerable<int> x)\n        {\n            return Math.Sqrt(x.Average(i => (double)i * i));\n        }\n    }\n}"}
{"title": "Babbage problem", "language": "C sharp|C#", "task": "Charles Babbage\nCharles Babbage's analytical engine.\n\nCharles Babbage, looking ahead to the sorts of problems his Analytical Engine would be able to solve, gave this example:\n{{quote\n | What is the smallest positive integer whose square ends in the digits 269,696?\n | Babbage, letter to Lord Bowden, 1837; see Hollingdale and Tootill, Electronic Computers, second edition, 1970, p. 125.\n}}\nHe thought the answer might be 99,736, whose square is 9,947,269,696; but he couldn't be certain.\n\n\n;Task\n\nThe task is to find out if Babbage had the right answer -- and to do so, as far as your language allows it, in code that Babbage himself would have been able to read and understand. \nAs Babbage evidently solved the task with pencil and paper, a similar efficient solution is preferred.\n\nFor these purposes, Charles Babbage may be taken to be an intelligent person, familiar with mathematics and with the idea of a computer; he has written the first drafts of simple computer programmes in tabular form. [Babbage Archive Series L].\n\n\n;Motivation\n\nThe aim of the task is to write a program that is sufficiently clear and well-documented for such a person to be able to read it and be confident that it does indeed solve the specified problem.\n\n", "solution": "namespace Babbage_Problem\n{\n    class iterateNumbers\n    {\n        public iterateNumbers()\n        {\n            long baseNumberSquared = 0; //the base number multiplied by itself\n            long baseNumber = 0;  //the number to be squared, this one will be iterated\n\n            do  //this sets up the loop\n            {\n                baseNumber += 1; //add one to the base number\n                baseNumberSquared = baseNumber * baseNumber; //multiply the base number by itself and store the value as baseNumberSquared\n            }\n            while (Right6Digits(baseNumberSquared) != 269696); //this will continue the loop until the right 6 digits of the base number squared are 269,696\n\n            Console.WriteLine(\"The smallest integer whose square ends in 269,696 is \" + baseNumber);\n            Console.WriteLine(\"The square is \" + baseNumberSquared);\n\n        }\n\n        private long Right6Digits(long baseNumberSquared)\n        {\n\n            string numberAsString = baseNumberSquared.ToString(); //this is converts the number to a different type so it can be cut up\n\n            if (numberAsString.Length < 6) { return baseNumberSquared; }; //if the number doesn't have 6 digits in it, just return it to try again.\n\n            numberAsString = numberAsString.Substring(numberAsString.Length - 6);  //this extracts the last 6 digits from the number\n\n            return long.Parse(numberAsString); //return the last 6 digits of the number\n\n        }\n    }\n}}"}
{"title": "Balanced brackets", "language": "C sharp|C#", "task": "'''Task''': \n* Generate a string with   '''N'''   opening brackets   '''['''   and with   '''N'''   closing brackets   ''']''',   in some arbitrary order. \n* Determine whether the generated string is ''balanced''; that is, whether it consists entirely of pairs of opening/closing brackets (in that order), none of which mis-nest.\n\n\n\n;Examples:\n    (empty)      OK\n    []           OK   \n    [][]         OK   \n    [[][]]       OK \n    ][         NOT OK\n    ][][       NOT OK\n    []][[]     NOT OK\n\n", "solution": "using System;\nusing System.Linq;\n\nclass Program\n{\n    static bool IsBalanced(string text, char open = '[', char close = ']')\n    {\n        var level = 0;\n        foreach (var character in text)\n        {\n            if (character == close)\n            {\n                if (level == 0)\n                {\n                    return false;\n                }\n                level--;\n            }\n            if (character == open)\n            {\n                level++;\n            }\n        }\n        return level == 0;\n    }\n\n    static string RandomBrackets(int count, char open = '[', char close = ']')\n    {\n        var random = new Random();\n        return string.Join(string.Empty,\n                (new string(open, count) + new string(close, count)).OrderBy(c => random.Next()));\n    }\n\n    static void Main()\n    {\n        for (var count = 0; count < 9; count++)\n        {\n            var text = RandomBrackets(count);\n            Console.WriteLine(\"\\\"{0}\\\" is {1}balanced.\", text, IsBalanced(text) ? string.Empty : \"not \");\n        }\n    }\n}"}
{"title": "Balanced ternary", "language": "C sharp|C#", "task": "Balanced ternary is a way of representing numbers.  Unlike the prevailing binary representation, a balanced ternary integer is in base 3, and each digit can have the values 1, 0, or -1.  \n\n\n;Examples:\nDecimal 11 = 32 + 31 - 30, thus it can be written as \"++-\"\n\nDecimal  6 = 32 - 31 + 0 x 30, thus it can be written as \"+-0\"\n\n\n;Task:\nImplement balanced ternary representation of integers with the following:\n# Support arbitrarily large integers, both positive and negative;\n# Provide ways to convert to and from text strings, using digits '+', '-' and '0' (unless you are already using strings to represent balanced ternary; but see requirement 5).\n# Provide ways to convert to and from native integer type (unless, improbably, your platform's native integer type ''is'' balanced ternary).  If your native integers can't support arbitrary length, overflows during conversion must be indicated.\n# Provide ways to perform addition, negation and multiplication directly on balanced ternary integers; do ''not'' convert to native integers first.\n# Make your implementation efficient, with a reasonable definition of \"efficient\" (and with a reasonable definition of \"reasonable\").\n\n\n'''Test case''' With balanced ternaries ''a'' from string \"+-0++0+\", ''b'' from native integer -436, ''c'' \"+-++-\":\n* write out ''a'', ''b'' and ''c'' in decimal notation;\n* calculate ''a'' x (''b'' - ''c''), write out the result in both ternary and decimal notations.\n\n\n'''Note:''' The pages floating point balanced ternary.\n\n", "solution": "using System;\nusing System.Text;\nusing System.Collections.Generic;\n\npublic class BalancedTernary\n{\n\tpublic static void Main()\n\t{\n\t\tBalancedTernary a = new BalancedTernary(\"+-0++0+\");\n\t\tSystem.Console.WriteLine(\"a: \" + a + \" = \" + a.ToLong());\n\t\tBalancedTernary b = new BalancedTernary(-436);\n\t\tSystem.Console.WriteLine(\"b: \" + b + \" = \" + b.ToLong());\n\t\tBalancedTernary c = new BalancedTernary(\"+-++-\");\n\t\tSystem.Console.WriteLine(\"c: \" + c + \" = \" + c.ToLong());\n\t\tBalancedTernary d = a * (b - c);\n\t\tSystem.Console.WriteLine(\"a * (b - c): \" + d + \" = \" + d.ToLong());\n\t}\n\n\tprivate enum BalancedTernaryDigit\n\t{\n\t\tMINUS = -1,\n\t\tZERO = 0,\n\t\tPLUS = 1\n\t}\n\n\tprivate BalancedTernaryDigit[] value;\n\n\t// empty = 0\n\tpublic BalancedTernary()\n\t{\n\t\tthis.value = new BalancedTernaryDigit[0];\n\t}\n\n\t// create from String\n\tpublic BalancedTernary(String str)\n\t{\n\t\tthis.value = new BalancedTernaryDigit[str.Length];\n\t\tfor (int i = 0; i < str.Length; ++i)\n\t\t{\n\t\t\tswitch (str[i])\n\t\t\t{\n\t\t\t\tcase '-':\n\t\t\t\t\tthis.value[i] = BalancedTernaryDigit.MINUS;\n\t\t\t\t\tbreak;\n\t\t\t\tcase '0':\n\t\t\t\t\tthis.value[i] = BalancedTernaryDigit.ZERO;\n\t\t\t\t\tbreak;\n\t\t\t\tcase '+':\n\t\t\t\t\tthis.value[i] = BalancedTernaryDigit.PLUS;\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tthrow new ArgumentException(\"Unknown Digit: \" + str[i]);\n\t\t\t}\n\t\t}\n\t\tArray.Reverse(this.value);\n\t}\n\n\t// convert long integer\n\tpublic BalancedTernary(long l)\n\t{\n\t\tList<BalancedTernaryDigit> value = new List<BalancedTernaryDigit>();\n\t\tint sign = Math.Sign(l);\n\t\tl = Math.Abs(l);\n\t\t\n\t\twhile (l != 0)\n\t\t{\n\t\t\tbyte rem = (byte)(l % 3);\n\t\t\tswitch (rem)\n\t\t\t{\n\t\t\t\tcase 0:\n\t\t\t\tcase 1:\n\t\t\t\t\tvalue.Add((BalancedTernaryDigit)rem);\n\t\t\t\t\tl /= 3;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 2:\n\t\t\t\t\tvalue.Add(BalancedTernaryDigit.MINUS);\n\t\t\t\t\tl = (l + 1) / 3;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tthis.value = value.ToArray();\n\t\tif (sign < 0)\n\t\t{\n\t\t\tthis.Invert();\n\t\t}\n\t}\n\n\t// copy constructor\n\tpublic BalancedTernary(BalancedTernary origin)\n\t{\n\t\tthis.value = new BalancedTernaryDigit[origin.value.Length];\n\t\tArray.Copy(origin.value, this.value, origin.value.Length);\n\t}\n\n\t// only for internal use\n\tprivate BalancedTernary(BalancedTernaryDigit[] value)\n\t{\n\t\tint end = value.Length - 1;\n\t\twhile (value[end] == BalancedTernaryDigit.ZERO)\n\t\t\t--end;\n\t\tthis.value = new BalancedTernaryDigit[end + 1];\n\t\tArray.Copy(value, this.value, end + 1);\n\t}\n\n\t// invert the values\n\tprivate void Invert()\n\t{\n\t\tfor (int i=0; i < this.value.Length; ++i)\n\t\t{\n\t\t\tthis.value[i] = (BalancedTernaryDigit)(-(int)this.value[i]);\n\t\t}\n\t}\n\n\t// convert to string\n\toverride public String ToString()\n\t{\n\t\tStringBuilder result = new StringBuilder();\n\t\tfor (int i = this.value.Length - 1; i >= 0; --i)\n\t\t{\n\t\t\tswitch (this.value[i])\n\t\t\t{\n\t\t\t\tcase BalancedTernaryDigit.MINUS:\n\t\t\t\t\tresult.Append('-');\n\t\t\t\t\tbreak;\n\t\t\t\tcase BalancedTernaryDigit.ZERO:\n\t\t\t\t\tresult.Append('0');\n\t\t\t\t\tbreak;\n\t\t\t\tcase BalancedTernaryDigit.PLUS:\n\t\t\t\t\tresult.Append('+');\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn result.ToString();\n\t}\n\n\t// convert to long\n\tpublic long ToLong()\n\t{\n\t\tlong result = 0;\n\t\tint digit;\n\t\tfor (int i = 0; i < this.value.Length; ++i)\n\t\t{\n\t\t\tresult += (long)this.value[i] * (long)Math.Pow(3.0, (double)i);\n\t\t}\n\t\treturn result;\n\t}\n\n\t// unary minus\n\tpublic static BalancedTernary operator -(BalancedTernary origin)\n\t{\n\t\tBalancedTernary result = new BalancedTernary(origin);\n\t\tresult.Invert();\n\t\treturn result;\n\t}\n\n\t// addition of digits\n\tprivate static BalancedTernaryDigit carry = BalancedTernaryDigit.ZERO;\n\tprivate static BalancedTernaryDigit Add(BalancedTernaryDigit a, BalancedTernaryDigit b)\n\t{\n\t\tif (a != b)\n\t\t{\n\t\t\tcarry = BalancedTernaryDigit.ZERO;\n\t\t\treturn (BalancedTernaryDigit)((int)a + (int)b);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tcarry = a;\n\t\t\treturn (BalancedTernaryDigit)(-(int)b);\n\t\t}\n\t}\n\n\t// addition of balanced ternary numbers\n\tpublic static BalancedTernary operator +(BalancedTernary a, BalancedTernary b)\n\t{\n\t\tint maxLength = Math.Max(a.value.Length, b.value.Length);\n\t\tBalancedTernaryDigit[] resultValue = new BalancedTernaryDigit[maxLength + 1];\n\t\tfor (int i=0; i < maxLength; ++i)\n\t\t{\n\t\t\tif (i < a.value.Length)\n\t\t\t{\n\t\t\t\tresultValue[i] = Add(resultValue[i], a.value[i]);\n\t\t\t\tresultValue[i+1] = carry;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tcarry = BalancedTernaryDigit.ZERO;\n\t\t\t}\n\t\t\t\n\t\t\tif (i < b.value.Length)\n\t\t\t{\n\t\t\t\tresultValue[i] = Add(resultValue[i], b.value[i]);\n\t\t\t\tresultValue[i+1] = Add(resultValue[i+1], carry);\n\t\t\t}\n\t\t}\n\t\treturn new BalancedTernary(resultValue);\n\t}\n\n\t// subtraction of balanced ternary numbers\n\tpublic static BalancedTernary operator -(BalancedTernary a, BalancedTernary b)\n\t{\n\t\treturn a + (-b);\n\t}\n\n\t// multiplication of balanced ternary numbers\n\tpublic static BalancedTernary operator *(BalancedTernary a, BalancedTernary b)\n\t{\n\t\tBalancedTernaryDigit[] longValue = a.value;\n\t\tBalancedTernaryDigit[] shortValue = b.value;\n\t\tBalancedTernary result = new BalancedTernary();\n\t\tif (a.value.Length < b.value.Length)\n\t\t{\n\t\t\tlongValue = b.value;\n\t\t\tshortValue = a.value;\n\t\t}\n\n\t\tfor (int i = 0; i < shortValue.Length; ++i)\n\t\t{\n\t\t\tif (shortValue[i] != BalancedTernaryDigit.ZERO)\n\t\t\t{\n\t\t\t\tBalancedTernaryDigit[] temp = new BalancedTernaryDigit[i + longValue.Length];\n\t\t\t\tfor (int j = 0; j < longValue.Length; ++j)\n\t\t\t\t{\n\t\t\t\t\ttemp[i+j] = (BalancedTernaryDigit)((int)shortValue[i] * (int)longValue[j]);\n\t\t\t\t}\n\t\t\t\tresult = result + new BalancedTernary(temp);\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n}"}
{"title": "Barnsley fern", "language": "C sharp|C#", "task": "A Barnsley fern is a fractal named after British mathematician Michael Barnsley and can be created using an iterated function system (IFS).\n\n\n;Task:\nCreate this fractal fern, using the following transformations:\n* f1   (chosen 1% of the time)\n         xn + 1 = 0\n         yn + 1 = 0.16 yn\n\n* f2   (chosen 85% of the time)\n         xn + 1 = 0.85 xn + 0.04 yn\n         yn + 1 = -0.04 xn + 0.85 yn + 1.6\n\n* f3   (chosen 7% of the time)\n         xn + 1 = 0.2 xn - 0.26 yn\n         yn + 1 = 0.23 xn + 0.22 yn + 1.6\n\n* f4   (chosen 7% of the time)\n         xn + 1 = -0.15 xn + 0.28 yn\n         yn + 1 = 0.26 xn + 0.24 yn + 0.44.\n\nStarting position: x = 0, y = 0\n\n", "solution": "using System;\nusing System.Diagnostics;\nusing System.Drawing;\n\nnamespace RosettaBarnsleyFern\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            const int w = 600;\n            const int h = 600;\n            var bm = new Bitmap(w, h);\n            var r = new Random();\n            double x = 0;\n            double y = 0;\n            for (int count = 0; count < 100000; count++)\n            {\n                bm.SetPixel((int)(300 + 58 * x), (int)(58 * y), Color.ForestGreen);\n                int roll = r.Next(100);\n                double xp = x;\n                if (roll < 1)\n                {\n                    x = 0;\n                    y = 0.16 * y;\n                } else if (roll < 86)\n                {\n                    x = 0.85 * x + 0.04 * y;\n                    y = -0.04 * xp + 0.85 * y + 1.6;\n                } else if (roll < 93)\n                {\n                    x = 0.2 * x - 0.26 * y;\n                    y = 0.23 * xp + 0.22 * y + 1.6;\n                } else\n                {\n                    x = -0.15 * x + 0.28 * y;\n                    y = 0.26 * xp + 0.24 * y + 0.44;\n                }\n            }\n            const string filename = \"Fern.png\";\n            bm.Save(filename);\n            Process.Start(filename);\n        }\n    }\n}"}
{"title": "Base64 decode data", "language": "C sharp|C# from Visual Basic .NET", "task": "See [[Base64 encode data]]. \n\nNow write a program that takes the output of the [[Base64 encode data]] task as input and regenerate the original file. \n\nWhen working on the VBA implementation I found several 'solutions' on the net, including one from the software maker himself, that showed output with incorrect padding. Obviously with incorrect padding in the output you can not decode correctly to the original file again.\n\n", "solution": "using System;\nusing System.Text;\n\nnamespace Base64DecodeData {\n    class Program {\n        static void Main(string[] args) {\n            var data = \"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=\";\n            Console.WriteLine(data);\n            Console.WriteLine();\n\n            var decoded = Encoding.ASCII.GetString(Convert.FromBase64String(data));\n            Console.WriteLine(decoded);\n        }\n    }\n}"}
{"title": "Bell numbers", "language": "C sharp|C# from D", "task": "Bell or exponential numbers are enumerations of the number of different ways to partition a set that has exactly '''n''' elements. Each element of the sequence '''Bn''' is the number of partitions of a set of size '''n''' where order of the elements and order of the partitions are non-significant. E.G.: '''{a b}''' is the same as '''{b a}''' and '''{a} {b}''' is the same as '''{b} {a}'''.\n\n\n;So:\n\n:'''B0 = 1''' trivially. There is only one way to partition a set with zero elements. '''{ }'''\n\n:'''B1 = 1''' There is only one way to partition a set with one element. '''{a}'''\n\n:'''B2 = 2''' Two elements may be partitioned in two ways. '''{a} {b}, {a b}'''\n\n:'''B3 = 5''' Three elements may be partitioned in five ways '''{a} {b} {c}, {a b} {c}, {a} {b c}, {a c} {b}, {a b c}'''\n\n: and so on.\n\n\nA simple way to find the Bell numbers is construct a '''Bell triangle''', also known as an '''Aitken's array''' or '''Peirce triangle''', and read off the numbers in the first column of each row. There are other generating algorithms though, and you are free to choose the best / most appropriate for your case.\n\n\n;Task:\n\nWrite a routine (function, generator, whatever) to generate the Bell number sequence and call the routine to show here, on this page at least the '''first 15''' and (if your language supports big Integers) '''50th''' elements of the sequence. \n\nIf you ''do'' use the Bell triangle method to generate the numbers, also show the '''first ten rows''' of the Bell triangle.\n\n\n;See also:\n\n:* '''OEIS:A000110 Bell or exponential numbers'''\n:* '''OEIS:A011971 Aitken's array'''\n\n", "solution": "using System;\nusing System.Numerics;\n\nnamespace BellNumbers {\n    public static class Utility {\n        public static void Init<T>(this T[] array, T value) {\n            if (null == array) return;\n            for (int i = 0; i < array.Length; ++i) {\n                array[i] = value;\n            }\n        }\n    }\n\n    class Program {\n        static BigInteger[][] BellTriangle(int n) {\n            BigInteger[][] tri = new BigInteger[n][];\n            for (int i = 0; i < n; ++i) {\n                tri[i] = new BigInteger[i];\n                tri[i].Init(BigInteger.Zero);\n            }\n            tri[1][0] = 1;\n            for (int i = 2; i < n; ++i) {\n                tri[i][0] = tri[i - 1][i - 2];\n                for (int j = 1; j < i; ++j) {\n                    tri[i][j] = tri[i][j - 1] + tri[i - 1][j - 1];\n                }\n            }\n            return tri;\n        }\n\n        static void Main(string[] args) {\n            var bt = BellTriangle(51);\n            Console.WriteLine(\"First fifteen and fiftieth Bell numbers:\");\n            for (int i = 1; i < 16; ++i) {\n                Console.WriteLine(\"{0,2}: {1}\", i, bt[i][0]);\n            }\n            Console.WriteLine(\"50: {0}\", bt[50][0]);\n            Console.WriteLine();\n            Console.WriteLine(\"The first ten rows of Bell's triangle:\");\n            for (int i = 1; i < 11; ++i) {\n                //Console.WriteLine(bt[i]);\n                var it = bt[i].GetEnumerator();\n                Console.Write(\"[\");\n                if (it.MoveNext()) {\n                    Console.Write(it.Current);\n                }\n                while (it.MoveNext()) {\n                    Console.Write(\", \");\n                    Console.Write(it.Current);\n                }\n                Console.WriteLine(\"]\");\n            }\n        }\n    }\n}"}
{"title": "Best shuffle", "language": "C sharp|C#", "task": "Shuffle the characters of a string in such a way that as many of the character values are in a different position as possible. \n\nA shuffle that produces a randomized result among the best choices is to be preferred. A deterministic approach that produces the same sequence every time is acceptable as an alternative.\n\nDisplay the result as follows: \n\n original string, shuffled string, (score) \n\nThe score gives the number of positions whose character value did ''not'' change. \n\n\n;Example:\n tree, eetr, (0)\n\n\n;Test cases:\n abracadabra\n seesaw\n elk\n grrrrrr\n up\n a\n\n\n;Related tasks\n*   [[Anagrams/Deranged anagrams]]\n*   [[Permutations/Derangements]]\n\n\n\n", "solution": "using System;\nusing System.Text;\nusing System.Collections.Generic;\n\nnamespace BestShuffle_RC\n{\n    public class ShuffledString\n    {\n        private string original;\n        private StringBuilder shuffled;\n        private int ignoredChars;\n\n        public string Original\n        {\n            get { return original; }\n        }\n\n        public string Shuffled\n        {\n            get { return shuffled.ToString(); }\n        }\n\n        public int Ignored\n        {\n            get { return ignoredChars; }\n        }\n\n        private void Swap(int pos1, int pos2)\n        {\n            char temp = shuffled[pos1];\n            shuffled[pos1] = shuffled[pos2];\n            shuffled[pos2] = temp;\n        }\n\n        //Determine if a swap between these two would put a letter in a \"bad\" place\n        //If true, a swap is OK. \n        private bool TrySwap(int pos1, int pos2)\n        {\n            if (original[pos1] == shuffled[pos2] || original[pos2] == shuffled[pos1])\n                return false;\n            else\n                return true;\n        }\n\n        //Constructor carries out calls Shuffle function. \n        public ShuffledString(string word)\n        {\n            original = word;\n            shuffled = new StringBuilder(word);\n            Shuffle();\n            DetectIgnores();\n        }\n\n        //Does the hard work of shuffling the string.\n        private void Shuffle()\n        {\n            int length = original.Length;\n            int swaps;\n            Random rand = new Random();\n            List<int> used = new List<int>();\n\n            for (int i = 0; i < length; i++)\n            {\n                swaps = 0;\n                while(used.Count <= length - i)//Until all possibilities have been tried\n                {\n                    int j = rand.Next(i, length - 1);\n                    //If swapping would make a difference, and wouldn't put a letter in a \"bad\" place,\n                    //and hasn't already been tried, then swap\n                    if (original[i] != original[j] && TrySwap(i, j) && !used.Contains(j))\n                    {\n                        Swap(i, j);\n                        swaps++;\n                        break;\n                    }\n                    else\n                        used.Add(j);//If swapping doesn't work, \"blacklist\" the index\n                }\n                if (swaps == 0)\n                {\n                    //If a letter was ignored (no swap was found), look backward for another change to make\n                    for (int k = i; k >= 0; k--)\n                    {\n                        if (TrySwap(i, k))\n                            Swap(i, k);\n                    }\n                }\n                //Clear the used indeces\n                used.Clear();\n            }\n        }\n\n        //Count how many letters are still in their original places.\n        private void DetectIgnores()\n        {\n            int ignores = 0;\n            for (int i = 0; i < original.Length; i++)\n            {\n                if (original[i] == shuffled[i])\n                    ignores++;\n            }\n\n            ignoredChars = ignores;\n        }\n\n        //To allow easy conversion of strings.\n        public static implicit operator ShuffledString(string convert)\n        {\n            return new ShuffledString(convert);\n        }\n    }\n\n    public class Program\n    {\n        public static void Main(string[] args)\n        {\n            ShuffledString[] words = { \"abracadabra\", \"seesaw\", \"elk\", \"grrrrrr\", \"up\", \"a\" };\n\n            foreach(ShuffledString word in words)\n                Console.WriteLine(\"{0}, {1}, ({2})\", word.Original, word.Shuffled, word.Ignored);\n\n            Console.ReadKey();\n        }\n    }\n}\n"}
{"title": "Bin given limits", "language": "C sharp|C#", "task": "You are given a list of n ascending, unique numbers which are to form limits\nfor n+1 bins which count how many of a large set of input numbers fall in the\nrange of each bin.\n\n(Assuming zero-based indexing)\n\n    bin[0] counts how many inputs are < limit[0]\n    bin[1] counts how many inputs are >= limit[0] and < limit[1]\n    ..''\n    bin[n-1] counts how many inputs are >= limit[n-2] and < limit[n-1]\n    bin[n] counts how many inputs are >= limit[n-1]\n\n;Task:\nThe task is to create a function that given the ascending limits and a stream/\nlist of numbers, will return the bins; together with another function that\ngiven the same list of limits and the binning will ''print the limit of each bin\ntogether with the count of items that fell in the range''.\n\nAssume the numbers to bin are too large to practically sort.\n\n;Task examples:\nPart 1: Bin using the following limits the given input data\n\n    limits  = [23, 37, 43, 53, 67, 83]\n    data = [95,21,94,12,99,4,70,75,83,93,52,80,57,5,53,86,65,17,92,83,71,61,54,58,47,\n            16, 8, 9,32,84,7,87,46,19,30,37,96,6,98,40,79,97,45,64,60,29,49,36,43,55]\n\nPart 2: Bin using the following limits the given input data\n\n    limits = [14, 18, 249, 312, 389, 392, 513, 591, 634, 720]\n    data = [445,814,519,697,700,130,255,889,481,122,932, 77,323,525,570,219,367,523,442,933,\n            416,589,930,373,202,253,775, 47,731,685,293,126,133,450,545,100,741,583,763,306,\n            655,267,248,477,549,238, 62,678, 98,534,622,907,406,714,184,391,913, 42,560,247,\n            346,860, 56,138,546, 38,985,948, 58,213,799,319,390,634,458,945,733,507,916,123,\n            345,110,720,917,313,845,426,  9,457,628,410,723,354,895,881,953,677,137,397, 97,\n            854,740, 83,216,421, 94,517,479,292,963,376,981,480, 39,257,272,157,  5,316,395,\n            787,942,456,242,759,898,576, 67,298,425,894,435,831,241,989,614,987,770,384,692,\n            698,765,331,487,251,600,879,342,982,527,736,795,585, 40, 54,901,408,359,577,237,\n            605,847,353,968,832,205,838,427,876,959,686,646,835,127,621,892,443,198,988,791,\n            466, 23,707,467, 33,670,921,180,991,396,160,436,717,918,  8,374,101,684,727,749]\n\nShow output here, on this page.\n", "solution": "using System;\n\npublic class Program\n{\n    static void Main()\n    {\n        PrintBins(new [] { 23, 37, 43, 53, 67, 83 },\n            95,21,94,12,99,4,70,75,83,93,52,80,57,5,53,86,65,17,92,83,71,61,54,58,47,\n            16, 8, 9,32,84,7,87,46,19,30,37,96,6,98,40,79,97,45,64,60,29,49,36,43,55\n        );\n        Console.WriteLine();\n\n        PrintBins(new [] { 14, 18, 249, 312, 389, 392, 513, 591, 634, 720 },\n            445,814,519,697,700,130,255,889,481,122,932, 77,323,525,570,219,367,523,442,933,416,589,930,373,202,\n            253,775, 47,731,685,293,126,133,450,545,100,741,583,763,306,655,267,248,477,549,238, 62,678, 98,534,\n            622,907,406,714,184,391,913, 42,560,247,346,860, 56,138,546, 38,985,948, 58,213,799,319,390,634,458,\n            945,733,507,916,123,345,110,720,917,313,845,426,  9,457,628,410,723,354,895,881,953,677,137,397, 97,\n            854,740, 83,216,421, 94,517,479,292,963,376,981,480, 39,257,272,157,  5,316,395,787,942,456,242,759,\n            898,576, 67,298,425,894,435,831,241,989,614,987,770,384,692,698,765,331,487,251,600,879,342,982,527,\n            736,795,585, 40, 54,901,408,359,577,237,605,847,353,968,832,205,838,427,876,959,686,646,835,127,621,\n            892,443,198,988,791,466, 23,707,467, 33,670,921,180,991,396,160,436,717,918,  8,374,101,684,727,749);\n    }\n\n    static void PrintBins(int[] limits, params int[] data)\n    {\n        int[] bins = Bins(limits, data);\n        Console.WriteLine($\"-\u221e .. {limits[0]} => {bins[0]}\");\n        for (int i = 0; i < limits.Length-1; i++) {\n            Console.WriteLine($\"{limits[i]} .. {limits[i+1]} => {bins[i+1]}\");\n        }\n        Console.WriteLine($\"{limits[^1]} .. \u221e => {bins[^1]}\");\n    }\n\n    static int[] Bins(int[] limits, params int[] data)\n    {\n        Array.Sort(limits);\n        int[] bins = new int[limits.Length + 1];\n        foreach (int n in data) {\n            int i = Array.BinarySearch(limits, n);\n            i = i < 0 ? ~i : i+1;\n            bins[i]++;\n        }\n        return bins;\n    }\n}"}
{"title": "Bitcoin/address validation", "language": "C sharp|C#", "task": "Write a program that takes a bitcoin address as argument, \nand checks whether or not this address is valid.\n\nA bitcoin address uses a base58 encoding, which uses an alphabet of the characters 0 .. 9, A ..Z, a .. z, but without the four characters:\n:::*   0   zero\n:::*   O   uppercase oh\n:::*   I   uppercase eye\n:::*   l   lowercase ell\n\n\nWith this encoding, a bitcoin address encodes 25 bytes:\n* the first byte is the version number, which will be zero for this task ;\n* the next twenty bytes are a [[RIPEMD-160]] digest, but you don't have to know that for this task:  you can consider them a pure arbitrary data ;\n* the last four bytes are a checksum check.  They are the first four bytes of a double [[SHA-256]] digest of the previous 21 bytes.\n\n\nTo check the bitcoin address, you must read the first twenty-one bytes, compute the checksum, and check that it corresponds to the last four bytes.\n\nThe program can either return a boolean value or throw an exception when not valid.\n\nYou can use a digest library for [[SHA-256]].\n\n\n;Example of a bitcoin address:\n\n 1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i\n\n\nIt doesn't belong to anyone and is part of the test suite of the bitcoin software.   \nYou can change a few characters in this string and check that it'll fail the test.\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Security.Cryptography;\nusing NUnit.Framework;\n\nnamespace BitcoinValidator\n{\n    public class ValidateTest\n    {\n        [TestCase]\n        public void ValidateBitcoinAddressTest()\n        {\n            Assert.IsTrue(ValidateBitcoinAddress(\"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i\")); // VALID\n            Assert.IsTrue(ValidateBitcoinAddress(\"1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nK9\")); // VALID\n            Assert.Throws<Exception>(() => ValidateBitcoinAddress(\"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62X\")); // checksum changed, original data\n            Assert.Throws<Exception>(() => ValidateBitcoinAddress(\"1ANNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i\")); // data changed, original checksum\n            Assert.Throws<Exception>(() => ValidateBitcoinAddress(\"1A Na15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i\")); // invalid chars\n            Assert.Throws<Exception>(() => ValidateBitcoinAddress(\"BZbvjr\")); // checksum is fine, address too short\n        }\n\n        public static bool ValidateBitcoinAddress(string address)\n        {\n            if (address.Length < 26 || address.Length > 35) throw new Exception(\"wrong length\");\n            var decoded = DecodeBase58(address);\n            var d1 = Hash(decoded.SubArray(0, 21));\n            var d2 = Hash(d1);\n            if (!decoded.SubArray(21, 4).SequenceEqual(d2.SubArray(0, 4))) throw new Exception(\"bad digest\");\n            return true;\n        }\n\n        const string Alphabet = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\";\n        const int Size = 25;\n\n        private static byte[] DecodeBase58(string input)\n        {\n            var output = new byte[Size];\n            foreach (var t in input)\n            {\n                var p = Alphabet.IndexOf(t);\n                if (p == -1) throw new Exception(\"invalid character found\");\n                var j = Size;\n                while (--j > 0)\n                {\n                    p += 58 * output[j];\n                    output[j] = (byte)(p % 256);\n                    p /= 256;\n                }\n                if (p != 0) throw new Exception(\"address too long\");\n            }\n            return output;\n        }\n\n        private static byte[] Hash(byte[] bytes)\n        {\n            var hasher = new SHA256Managed();\n            return hasher.ComputeHash(bytes);\n        }\n    }\n\n    public static class ArrayExtensions\n    {\n        public static T[] SubArray<T>(this T[] data, int index, int length)\n        {\n            var result = new T[length];\n            Array.Copy(data, index, result, 0, length);\n            return result;\n        }\n    }\n}\n"}
{"title": "Bitwise IO", "language": "C sharp|C#", "task": "The aim of this task is to write functions (or create a class if yourlanguage is Object Oriented and you prefer) for reading and writing sequences of\nbits, most significant bit first. While the output of a asciiprint \"STRING\" is the ASCII byte sequence\n\"S\", \"T\", \"R\", \"I\", \"N\", \"G\", the output of a \"print\" of the bits sequence\n0101011101010 (13 bits) must be 0101011101010; real I/O is performed always\n''quantized'' by byte (avoiding endianness issues and relying on underlying\nbuffering for performance), therefore you must obtain as output the bytes\n0101 0111 0101 0'''000''' (bold bits are padding bits), i.e. in hexadecimal 57 50.\n\nAs test, you can implement a '''rough''' (e.g. don't care about error handling or\nother issues) compression/decompression program for ASCII sequences\nof bytes, i.e. bytes for which the most significant bit is always unused, so that you can write\nseven bits instead of eight (each 8 bytes of input, we write 7 bytes of output).\n\nThese bit oriented I/O functions can be used to implement compressors and\ndecompressors; e.g. Dynamic and Static Huffman encodings use variable length\nbits sequences, while LZW (see [[LZW compression]]) use fixed or variable ''words''\nnine (or more) bits long.\n\n* Limits in the maximum number of bits that can be written/read in a single read/write operation are allowed.\n* Errors handling is not mandatory\n\n", "solution": "using System;\nusing System.IO;\n\npublic class BitReader\n{\n    uint readData = 0;\n    int startPosition = 0;\n    int endPosition = 0;\n\n    public int InBuffer\n    {\n        get { return endPosition - startPosition; }\n    }\n\n    private Stream stream;\n\n    public Stream BaseStream\n    {\n        get { return stream; }\n    }\n\n    public BitReader(Stream stream)\n    {\n        this.stream = stream;\n    }\n\n    void EnsureData(int bitCount)\n    {\n        int readBits = bitCount - InBuffer;\n        while (readBits > 0)\n        {\n            int b = BaseStream.ReadByte();\n\n            if (b < 0) throw new InvalidOperationException(\"Unexpected end of stream\");\n\n            readData |= checked((uint)b << endPosition);\n            endPosition += 8;\n            readBits -= 8;\n        }\n    }\n\n    public bool ReadBit()\n    {\n        return Read(1) > 0;\n    }\n\n    public int Read(int bitCount)\n    {\n        EnsureData(bitCount);\n\n        int result = (int)(readData >> startPosition) & ((1 << bitCount) - 1);\n        startPosition += bitCount;\n        if (endPosition == startPosition)\n        {\n            endPosition = startPosition = 0;\n            readData = 0;\n        }\n        else if (startPosition >= 8)\n        {\n            readData >>= startPosition;\n            endPosition -= startPosition;\n            startPosition = 0;\n        }\n\n        return result;\n    }\n\n    public void Align()\n    {\n        endPosition = startPosition = 0;\n        readData = 0;\n    }\n}\n\npublic class BitWriter\n{\n    uint data = 0;\n    int dataLength = 0;\n    Stream stream;\n\n    public Stream BaseStream\n    {\n        get { return stream; }\n    }\n\n    public int BitsToAligment\n    {\n        get { return (32 - dataLength) % 8; }\n    }\n\n    public BitWriter(Stream stream)\n    {\n        this.stream = stream;\n    }\n\n    public void WriteBit(bool value)\n    {\n        Write(value ? 1 : 0, 1);\n    }\n\n    public void Write(int value, int length)\n    {\n        uint currentData = data | checked((uint)value << dataLength);\n        int currentLength = dataLength + length;\n        while (currentLength >= 8)\n        {\n            BaseStream.WriteByte((byte)currentData);\n            currentData >>= 8;\n            currentLength -= 8;\n        }\n        data = currentData;\n        dataLength = currentLength;\n    }\n\n    public void Align()\n    {\n        if (dataLength > 0)\n        {\n            BaseStream.WriteByte((byte)data);\n\n            data = 0;\n            dataLength = 0;\n        }\n    }\n}\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        MemoryStream ms = new MemoryStream();\n        BitWriter writer = new BitWriter(ms);\n        writer.WriteBit(true);\n        writer.Write(5, 3);\n        writer.Write(0x0155, 11);\n        writer.Align();\n\n        ms.Position = 0;\n        BitReader reader = new BitReader(ms);\n        Console.WriteLine(reader.ReadBit());\n        Console.WriteLine(reader.Read(3));\n        Console.WriteLine(reader.Read(11).ToString(\"x4\"));\n        reader.Align();\n    }\n}"}
{"title": "Box the compass", "language": "C sharp|C#", "task": "Avast me hearties!\nThere be many a land lubber that knows naught of the pirate ways and gives direction by degree!\nThey know not how to box the compass! \n\n\n;Task description:\n# Create a function that takes a heading in degrees and returns the correct 32-point compass heading.\n# Use the function to print and display a table of Index, Compass point, and Degree; rather like the corresponding columns from, the first table of the wikipedia article, but use only the following 33 headings as input:\n:[0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]. (They should give the same order of points but are spread throughout the ranges of acceptance).\n\n\n;Notes;\n* The headings and indices can be calculated from this pseudocode:\nfor i in 0..32 inclusive:\n    heading = i * 11.25\n    case i %3:\n      if 1: heading += 5.62; break\n      if 2: heading -= 5.62; break\n    end\n    index = ( i mod 32) + 1\n* The column of indices can be thought of as an enumeration of the thirty two cardinal points (see talk page)..\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace BoxTheCompass\n{\n    class Compass\n    {\n        string[] cp = new string[] {\"North\", \"North by east\", \"North-northeast\", \"Northeast by north\", \"Northeast\",\"Northeast by east\", \n\t    \"East-northeast\", \"East by north\", \"East\", \"East by south\", \"East-southeast\", \"Southeast by east\", \"Southeast\", \n            \"Southeast by south\", \"South-southeast\", \"South by east\", \"South\", \"South by west\", \"South-southwest\", \"Southwest by south\", \n            \"Southwest\", \"Southwest by west\", \"West-southwest\", \"West by south\", \"West\", \"West by north\", \"West-northwest\", \n            \"Northwest by west\", \"Northwest\", \"Northwest by north\", \"North-northwest\", \"North by west\", \"North\"};\n\n        public void compassHeading(float a)\n        {\n            int h = Convert.ToInt32(Math.Floor(a / 11.25f + .5f)) % 32;\n            Console.WriteLine( \"{0,2}: {1,-22} : {2,6:N}\",h + 1, cp[h], a );\n        }\n    };\n    class Program\n    {\n        static void Main(string[] args)\n       {\n            Compass c = new Compass();\n            float[] degs = new float[] {0.0f, 16.87f, 16.88f, 33.75f, 50.62f, 50.63f, 67.5f, 84.37f, 84.38f, 101.25f, \n                118.12f, 118.13f, 135.0f, 151.87f, 151.88f, 168.75f, 185.62f, 185.63f, 202.5f, 219.37f, 219.38f, 236.25f, \n                253.12f, 253.13f, 270.0f, 286.87f, 286.88f, 303.75f, 320.62f, 320.63f, 337.5f, 354.37f, 354.38f};\n\n            foreach (float d in degs)\n                c.compassHeading(d);\n\n            Console.WriteLine(\"\\nPress any key to continue...\");\n            Console.ReadKey();\n        }\n    }\n}\n"}
{"title": "Brazilian numbers", "language": "C sharp|C# from Go", "task": "Brazilian numbers are so called as they were first formally presented at the 1994 math Olympiad ''Olimpiada Iberoamericana de Matematica'' in Fortaleza, Brazil.\n\nBrazilian numbers are defined as:\n\nThe set of positive integer numbers where each number '''N''' has at least one natural number '''B''' where '''1 < B < N-1''' where the representation of '''N''' in '''base B''' has all equal digits.\n\n\n;E.G.:\n\n:* '''1, 2 & 3''' can not be Brazilian; there is no base '''B''' that satisfies the condition '''1 < B < N-1'''.\n:* '''4''' is not Brazilian; '''4''' in '''base 2''' is '''100'''. The digits are not all the same.\n:* '''5''' is not Brazilian; '''5''' in '''base 2''' is '''101''', in '''base 3''' is '''12'''. There is no representation where the digits are the same.\n:* '''6''' is not Brazilian; '''6''' in '''base 2''' is '''110''', in '''base 3''' is '''20''', in '''base 4''' is '''12'''. There is no representation where the digits are the same.\n:* '''7''' ''is'' Brazilian; '''7''' in '''base 2''' is '''111'''. There is at least one representation where the digits are all the same.\n:* '''8''' ''is'' Brazilian; '''8''' in '''base 3''' is '''22'''. There is at least one representation where the digits are all the same.\n:* ''and so on...''\n\n\nAll even integers '''2P >= 8''' are Brazilian because '''2P = 2(P-1) + 2''', which is '''22''' in '''base P-1''' when '''P-1 > 2'''. That becomes true when '''P >= 4'''.\nMore common: for all all integers '''R''' and '''S''', where '''R > 1''' and also '''S-1 > R''', then '''R*S''' is Brazilian because '''R*S = R(S-1) + R''', which is '''RR''' in '''base S-1'''\nThe only problematic numbers are squares of primes, where R = S. Only 11^2 is brazilian to base 3.   \nAll prime integers, that are brazilian, can only have the digit '''1'''. Otherwise one could factor out the digit, therefore it cannot be a prime number. Mostly in form of '''111''' to base Integer(sqrt(prime number)). Must be an odd count of '''1''' to stay odd like primes >  2\n\n;Task:\n\nWrite a routine (function, whatever) to determine if a number is Brazilian and use the routine to show here, on this page;\n\n:* the first '''20''' Brazilian numbers;\n:* the first '''20 odd''' Brazilian numbers;\n:* the first '''20 prime''' Brazilian numbers;\n\n\n;See also:\n\n:* '''OEIS:A125134 - Brazilian numbers'''\n:* '''OEIS:A257521 - Odd Brazilian numbers'''\n:* '''OEIS:A085104 - Prime Brazilian numbers'''\n\n", "solution": "using System;\nclass Program {\n \n  static bool sameDigits(int n, int b) {\n    int f = n % b;\n    while ((n /= b) > 0) if (n % b != f) return false;\n    return true;\n  }\n \n  static bool isBrazilian(int n) {\n    if (n < 7) return false;\n    if (n % 2 == 0) return true;\n    for (int b = 2; b < n - 1; b++) if (sameDigits(n, b)) return true;\n    return false;\n  }\n \n  static bool isPrime(int n) {\n    if (n < 2) return false;\n    if (n % 2 == 0) return n == 2;\n    if (n % 3 == 0) return n == 3;\n    int d = 5;\n    while (d * d <= n) {\n      if (n % d == 0) return false; d += 2;\n      if (n % d == 0) return false; d += 4;\n    }\n    return true;\n  }\n \n  static void Main(string[] args) {\n    foreach (string kind in \",odd ,prime \".Split(',')) {\n      bool quiet = false; int BigLim = 99999, limit = 20;\n      Console.WriteLine(\"First {0} {1}Brazilian numbers:\", limit, kind);\n      int c = 0, n = 7;\n      while (c < BigLim) {\n        if (isBrazilian(n)) {\n          if (!quiet) Console.Write(\"{0:n0} \", n);\n          if (++c == limit) { Console.Write(\"\\n\\n\"); quiet = true; }\n        }\n        if (quiet && kind != \"\") continue;\n        switch (kind) {\n          case \"\": n++; break;\n          case \"odd \": n += 2; break;\n          case \"prime \":\n            while (true) {\n              n += 2;\n              if (isPrime(n)) break;\n            } break;\n        }\n      }\n      if (kind == \"\") Console.WriteLine(\"The {0:n0}th Brazilian number is: {1:n0}\\n\", BigLim + 1, n);\n    }\n  }\n}"}
{"title": "Break OO privacy", "language": "C sharp|C#", "task": "Show how to access private or protected members of a class in an object-oriented language from outside an instance of the class, without calling non-private or non-protected members of the class as a proxy.  \nThe intent is to show how a debugger, serializer, or other meta-programming tool might access information that is barred by normal access methods to the object  but can nevertheless be accessed from within the language by some provided escape hatch or reflection mechanism. \nThe intent is specifically not to demonstrate heroic measures such as peeking and poking raw memory.\n\nNote that cheating on your type system is almost universally regarded \nas unidiomatic at best, and poor programming practice at worst.  \nNonetheless, if your language intentionally maintains a double-standard for OO privacy, here's where you can show it off.\n", "solution": "using System;\nusing System.Reflection;\n\npublic class MyClass\n{\n    private int answer = 42;\n}\n\npublic class Program\n{\n    public static void Main()\n    {\n        var myInstance = new MyClass();\n        var fieldInfo = typeof(MyClass).GetField(\"answer\", BindingFlags.NonPublic | BindingFlags.Instance);\n        var answer = fieldInfo.GetValue(myInstance);\n        Console.WriteLine(answer);\n    }\n}"}
{"title": "Burrows\u2013Wheeler transform", "language": "C sharp|C# from D", "task": "{{Wikipedia|Burrows-Wheeler_transform}}\n\n\nThe Burrows-Wheeler transform (BWT, also called block-sorting compression) rearranges a character string into runs of similar characters. \n\nThis is useful for compression, since it tends to be easy to compress a string that has runs of repeated characters by techniques such as move-to-front transform and run-length encoding. \n\nMore importantly, the transformation is reversible, without needing to store any additional data. \n\nThe BWT is thus a \"free\" method of improving the efficiency of text compression algorithms, costing only some extra computation.\n\n\nSource: Burrows-Wheeler transform\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace BurrowsWheeler {\n    class Program {\n        const char STX = (char)0x02;\n        const char ETX = (char)0x03;\n\n        private static void Rotate(ref char[] a) {\n            char t = a.Last();\n            for (int i = a.Length - 1; i > 0; --i) {\n                a[i] = a[i - 1];\n            }\n            a[0] = t;\n        }\n\n        // For some reason, strings do not compare how whould be expected\n        private static int Compare(string s1, string s2) {\n            for (int i = 0; i < s1.Length && i < s2.Length; ++i) {\n                if (s1[i] < s2[i]) {\n                    return -1;\n                }\n                if (s2[i] < s1[i]) {\n                    return 1;\n                }\n            }\n            if (s1.Length < s2.Length) {\n                return -1;\n            }\n            if (s2.Length < s1.Length) {\n                return 1;\n            }\n            return 0;\n        }\n\n        static string Bwt(string s) {\n            if (s.Any(a => a == STX || a == ETX)) {\n                throw new ArgumentException(\"Input can't contain STX or ETX\");\n            }\n            char[] ss = (STX + s + ETX).ToCharArray();\n            List<string> table = new List<string>();\n            for (int i = 0; i < ss.Length; ++i) {\n                table.Add(new string(ss));\n                Rotate(ref ss);\n            }\n            table.Sort(Compare);\n            return new string(table.Select(a => a.Last()).ToArray());\n        }\n\n        static string Ibwt(string r) {\n            int len = r.Length;\n            List<string> table = new List<string>(new string[len]);\n            for (int i = 0; i < len; ++i) {\n                for (int j = 0; j < len; ++j) {\n                    table[j] = r[j] + table[j];\n                }\n                table.Sort(Compare);\n            }\n            foreach (string row in table) {\n                if (row.Last() == ETX) {\n                    return row.Substring(1, len - 2);\n                }\n            }\n            return \"\";\n        }\n\n        static string MakePrintable(string s) {\n            return s.Replace(STX, '^').Replace(ETX, '|');\n        }\n\n        static void Main() {\n            string[] tests = new string[] {\n                \"banana\",\n                \"appellee\",\n                \"dogwood\",\n                \"TO BE OR NOT TO BE OR WANT TO BE OR NOT?\",\n                \"SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES\",\n                \"\\u0002ABC\\u0003\"\n            };\n\n            foreach (string test in tests) {\n                Console.WriteLine(MakePrintable(test));\n                Console.Write(\" --> \");\n\n                string t = \"\";\n                try {\n                    t = Bwt(test);\n                    Console.WriteLine(MakePrintable(t));\n                } catch (Exception e) {\n                    Console.WriteLine(\"ERROR: {0}\", e.Message);\n                }\n\n                string r = Ibwt(t);\n                Console.WriteLine(\" --> {0}\", r);\n                Console.WriteLine();\n            }\n        }\n    }\n}"}
{"title": "CSV data manipulation", "language": "C sharp|C#", "task": "CSV spreadsheet files are suitable for storing tabular data in a relatively portable way. \n\nThe CSV format is flexible but somewhat ill-defined.  \n\nFor present purposes, authors may assume that the data fields contain no commas, backslashes, or quotation marks.\n\n\n;Task:\nRead a CSV file, change some values and save the changes back to a file.\n\nFor this task we will use the following CSV file:\n\n C1,C2,C3,C4,C5\n 1,5,9,13,17\n 2,6,10,14,18\n 3,7,11,15,19\n 4,8,12,16,20\n\nSuggestions\n\n Show how to add a column, headed 'SUM', of the sums of the rows.\n If possible, illustrate the use of built-in or standard functions, methods, or libraries, that handle generic CSV files.\n\n\n", "solution": "using System.IO;\nusing System.Linq;\n\nnamespace CSV_data_manipulation\n{\n    class Program\n    {\n        static void Main()\n        {\n            var input = File.ReadAllLines(\"test_in.csv\");\n            var output = input.Select((line, i) =>\n            {\n                if (i == 0)\n                    return line + \",SUM\";\n                var sum = line.Split(',').Select(int.Parse).Sum();\n                return line + \",\" + sum;\n            }).ToArray();\n            File.WriteAllLines(\"test_out.csv\", output);\n        }\n    }\n}\n"}
{"title": "CSV to HTML translation", "language": "C sharp|C#", "task": "Consider a simplified CSV format where all rows are separated by a newline \nand all columns are separated by commas. \n\nNo commas are allowed as field data, but the data may contain \nother characters and character sequences that would \nnormally be   ''escaped''   when converted to HTML\n\n\n;Task:\nCreate a function that takes a string representation of the CSV data\nand returns a text string of an HTML table representing the CSV data. \n\nUse the following  data as the CSV text to convert, and show your output.\n: Character,Speech\n: The multitude,The messiah! Show us the messiah!\n: Brians mother,Now you listen here! He's not the messiah; he's a very naughty boy! Now go away!\n: The multitude,Who are you?\n: Brians mother,I'm his mother; that's who!\n: The multitude,Behold his mother! Behold his mother!\n\n\n;Extra credit:\n''Optionally'' allow special formatting for the first row of the table as if it is the tables header row \n(via  preferably; CSS if you must).\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Net;\n\n    class Program\n    {\n        private static string ConvertCsvToHtmlTable(string csvText)\n        {\n            //split the CSV, assume no commas or line breaks in text\n            List<List<string>> splitString = new List<List<string>>();\n            List<string> lineSplit = csvText.Split('\\n').ToList();\n            foreach (string line in lineSplit)\n            {\n                splitString.Add(line.Split(',').ToList());\n            }\n\n            //encode text safely, and create table\n            string tableResult = \"<table>\";\n            foreach(List<string> splitLine in splitString)\n            {\n                tableResult += \"<tr>\";\n                foreach(string splitText in splitLine)\n                {\n                    tableResult += \"<td>\" + WebUtility.HtmlEncode(splitText) + \"</td>\";\n                }\n                tableResult += \"</tr>\";\n            }\n            tableResult += \"</table>\";\n            return tableResult;\n        }\n    }\n"}
{"title": "CSV to HTML translation", "language": ".NET Framework", "task": "Consider a simplified CSV format where all rows are separated by a newline \nand all columns are separated by commas. \n\nNo commas are allowed as field data, but the data may contain \nother characters and character sequences that would \nnormally be   ''escaped''   when converted to HTML\n\n\n;Task:\nCreate a function that takes a string representation of the CSV data\nand returns a text string of an HTML table representing the CSV data. \n\nUse the following  data as the CSV text to convert, and show your output.\n: Character,Speech\n: The multitude,The messiah! Show us the messiah!\n: Brians mother,Now you listen here! He's not the messiah; he's a very naughty boy! Now go away!\n: The multitude,Who are you?\n: Brians mother,I'm his mother; that's who!\n: The multitude,Behold his mother! Behold his mother!\n\n\n;Extra credit:\n''Optionally'' allow special formatting for the first row of the table as if it is the tables header row \n(via  preferably; CSS if you must).\n\n", "solution": "Imports Microsoft.VisualBasic.FileIO\n\nModule Program\n    Sub Main(args As String())\n        Dim parser As TextFieldParser\n        Try\n            If args.Length > 1 Then\n                parser = My.Computer.FileSystem.OpenTextFieldParser(args(1), \",\")\n            Else\n                parser = New TextFieldParser(Console.In) With {.Delimiters = {\",\"}}\n            End If\n\n            Dim getLines =\n            Iterator Function() As IEnumerable(Of String())\n                Do Until parser.EndOfData\n                    Yield parser.ReadFields()\n                Loop\n            End Function\n\n            Dim result = CSVTOHTML(getLines(), If(args.Length > 0, Boolean.Parse(args(0)), False))\n\n            Console.WriteLine(result)\n        Finally\n            If parser IsNot Nothing Then parser.Dispose()\n        End Try\n    End Sub\n\n    Function CSVTOHTML(lines As IEnumerable(Of IEnumerable(Of String)), useTHead As Boolean) As XElement\n        Dim getRow = Function(row As IEnumerable(Of String)) From field In row Select <td><%= field %></td>\n\n        CSVTOHTML =\n<table>\n    <%= From l In lines.Select(\n            Function(line, i)\n                If useTHead AndAlso i = 0 Then\n                    Return <thead><%= getRow(line) %></thead>\n                Else\n                    Return <tr><%= getRow(line) %></tr>\n                End If\n            End Function) %>\n</table>\n    End Function\nEnd Module"}
{"title": "Calculating the value of e", "language": "C sharp|C#", "task": "Calculate the value of   ''e''.\n\n\n(''e''   is also known as   ''Euler's number''   and   ''Napier's constant''.)\n\n\nSee details: Calculating the value of e\n\n", "solution": "using System;\n\nnamespace CalculateE {\n    class Program {\n        public const double EPSILON = 1.0e-15;\n\n        static void Main(string[] args) {\n            ulong fact = 1;\n            double e = 2.0;\n            double e0;\n            uint n = 2;\n            do {\n                e0 = e;\n                fact *= n++;\n                e += 1.0 / fact;\n            } while (Math.Abs(e - e0) >= EPSILON);\n            Console.WriteLine(\"e = {0:F15}\", e);\n        }\n    }\n}"}
{"title": "Call a function", "language": "C sharp|C#", "task": "Demonstrate the different syntax and semantics provided for calling a function. \n\n\nThis may include:\n:*   Calling a function that requires no arguments\n:*   Calling a function with a fixed number of arguments\n:*   Calling a function with optional arguments\n:*   Calling a function with a variable number of arguments\n:*   Calling a function with named arguments\n:*   Using a function in statement context\n:*   Using a function in first-class context within an expression\n:*   Obtaining the return value of a function\n:*   Distinguishing built-in functions and user-defined functions\n:*   Distinguishing subroutines and functions\n;*   Stating whether arguments are passed by value or by reference\n;*   Is partial application possible and how\n\n\nThis task is ''not'' about defining functions.\n\n", "solution": "/* a function that has no argument */\n\tpublic int MyFunction();\n\n\t/* a function with a fixed number of arguments */\n\tFunctionWithArguments(4, 3, 2);\n\n\t/* a function with optional arguments */\n\tpublic void OptArg();\n\n\tpublic static void Main()\n\t{\n\t\tOptArg(1);\n\t\tOptArg(1, 2);\n\t\tOptArg(1, 2, 3);\n\t}\n\tpublic void ExampleMethod(int required, \n        string optionalstr = \"default string\",\n\t\tint optionalint = 10)\n\t/* If you know the first and the last parameter */\n\tExampleMethod(3, optionalint: 4);\n\n\t/* If you know all the parameter */\n\tExampleMethod(3, \"Hello World\", 4);\n\n\t/* Variable number of arguments use array */\n\tpublic static void UseVariableParameters(params int[] list) \n\n\t/* Obtain return value from function */\n\tpublic internal MyFunction();\n\tint returnValue = MyFunction();\n"}
{"title": "Canonicalize CIDR", "language": "C sharp|C#", "task": "Implement a function or program that, given a range of IPv4 addresses in CIDR notation (dotted-decimal/network-bits), will return/output the same range in canonical form. \n\nThat is, the IP address portion of the output CIDR block must not contain any set (1) bits in the host part of the address.\n\n\n;Example:\nGiven   '''87.70.141.1/22''',    your code should output    '''87.70.140.0/22'''\n\n\n;Explanation:\nAn Internet Protocol version 4 address is a 32-bit value, conventionally represented as a number in base 256 using dotted-decimal notation, where each base-256 digit is given in decimal and the digits are separated by periods. Logically, this 32-bit value represents two components: the leftmost (most-significant) bits determine the network portion of the address, while the rightmost (least-significant) bits determine the host portion. Classless Internet Domain Routing block notation indicates where the boundary between these two components is for a given address by adding a slash followed by the number of bits in the network portion.\n\nIn general, CIDR blocks stand in for the entire set of IP addresses sharing the same network component, so it's common to see access control lists that specify individual IP addresses using /32 to indicate that only the one address is included. Software accepting this notation as input often expects it to be entered in canonical form, in which the host bits are all zeroes. But network admins sometimes skip this step and just enter the address of a specific host on the subnet with the network size, resulting in a non-canonical entry.\n\nThe example address, 87.70.141.1/22, represents binary 0101011101000110100011 / 0100000001, with the / indicating the network/host division. To canonicalize, clear all the bits to the right of the / and convert back to dotted decimal: 0101011101000110100011 / 0000000000 - 87.70.140.0.\n\n\n;More examples for testing\n\n        36.18.154.103/12    -  36.16.0.0/12\n        62.62.197.11/29     -  62.62.197.8/29\n        67.137.119.181/4    -  64.0.0.0/4\n        161.214.74.21/24    -  161.214.74.0/24\n        184.232.176.184/18  -  184.232.128.0/18\n\n\n", "solution": "using System;\nusing System.Net;\nusing System.Linq;\n                    \npublic class Program\n{\n    public static void Main()\n    {\n        string[] tests = {\n            \"87.70.141.1/22\",\n            \"36.18.154.103/12\",\n            \"62.62.197.11/29\",\n            \"67.137.119.181/4\",\n            \"161.214.74.21/24\",\n            \"184.232.176.184/18\"\n        };\n        \n        foreach (string t in tests) Console.WriteLine($\"{t}   =>   {Canonicalize(t)}\");\n    }\n    \n    static string Canonicalize(string cidr) => CIDR.Parse(cidr).Canonicalize().ToString();\n}\n\nreadonly struct CIDR\n{\n    public readonly IPAddress ip;\n    public readonly int length;\n    \n    public static CIDR Parse(string cidr)\n    {\n        string[] parts = cidr.Split('/');\n        return new CIDR(IPAddress.Parse(parts[0]), int.Parse(parts[1]));\n    }\n    \n    public CIDR(IPAddress ip, int length) => (this.ip, this.length) = (ip, length);\n    \n    public CIDR Canonicalize() =>\n        new CIDR(\n            new IPAddress(\n                ToBytes(\n                    ToInt(\n                        ip.GetAddressBytes()\n                    )\n                    & ~((1 << (32 - length)) - 1)\n                )\n            ),\n            length\n        );\n    \n    private int ToInt(byte[] bytes) => bytes.Aggregate(0, (n, b) => (n << 8) | b);\n    \n    private byte[] ToBytes(int n)\n    {\n        byte[] bytes = new byte[4];\n        for (int i = 3; i >= 0; i--) {\n            bytes[i] = (byte)(n & 0xFF);\n            n >>= 8;\n        }\n        return bytes;\n    }\n    \n    public override string ToString() => $\"{ip}/{length}\";\n}"}
{"title": "Cantor set", "language": "C sharp|C# from Java", "task": "Draw a Cantor set.\n\n\nSee details at this Wikipedia webpage:   Cantor set\n\n", "solution": "using System;\n\nnamespace CantorSet {\n    class Program {\n        const int WIDTH = 81;\n        const int HEIGHT = 5;\n        private static char[,] lines = new char[HEIGHT, WIDTH];\n\n        static Program() {\n            for (int i = 0; i < HEIGHT; i++) {\n                for (int j = 0; j < WIDTH; j++) {\n                    lines[i, j] = '*';\n                }\n            }\n        }\n\n        private static void Cantor(int start, int len, int index) {\n            int seg = len / 3;\n            if (seg == 0) return;\n            for (int i = index; i < HEIGHT; i++) {\n                for (int j = start + seg; j < start + seg * 2; j++) {\n                    lines[i, j] = ' ';\n                }\n            }\n            Cantor(start, seg, index + 1);\n            Cantor(start + seg * 2, seg, index + 1);\n        }\n\n        static void Main(string[] args) {\n            Cantor(0, WIDTH, 1);\n            for (int i = 0; i < HEIGHT; i++) {\n                for (int j = 0; j < WIDTH; j++) {\n                    Console.Write(lines[i,j]);\n                }\n                Console.WriteLine();\n            }\n        }\n    }\n}"}
{"title": "Cartesian product of two or more lists", "language": "C sharp|C#", "task": "Show one or more idiomatic ways of generating the Cartesian product of two arbitrary lists in your language.\n\nDemonstrate that your function/method correctly returns:\n::{1, 2} x {3, 4} = {(1, 3), (1, 4), (2, 3), (2, 4)}\n\nand, in contrast:\n::{3, 4} x {1, 2} = {(3, 1), (3, 2), (4, 1), (4, 2)}\n\nAlso demonstrate, using your function/method, that the product of an empty list with any other list is empty.\n:: {1, 2} x {} = {}\n:: {} x {1, 2} = {}\n\nFor extra credit, show or write a function returning the n-ary product of an arbitrary number of lists, each of arbitrary length. Your function might, for example, accept a single argument which is itself a list of lists, and return the n-ary product of those lists.\n\nUse your n-ary Cartesian product function to show the following products:\n:: {1776, 1789} x {7, 12} x {4, 14, 23} x {0, 1}\n:: {1, 2, 3} x {30} x {500, 100}\n:: {1, 2, 3} x {} x {500, 100}\n\n\n", "solution": "using System;\npublic class Program\n{\n    public static void Main()\n    {\n        int[] empty = new int[0];\n        int[] list1 = { 1, 2 };\n        int[] list2 = { 3, 4 };\n        int[] list3 = { 1776, 1789 };\n        int[] list4 = { 7, 12 };\n        int[] list5 = { 4, 14, 23 };\n        int[] list6 = { 0, 1 };\n        int[] list7 = { 1, 2, 3 };\n        int[] list8 = { 30 };\n        int[] list9 = { 500, 100 };\n        \n        foreach (var sequenceList in new [] {\n            new [] { list1, list2 },\n            new [] { list2, list1 },\n            new [] { list1, empty },\n            new [] { empty, list1 },\n            new [] { list3, list4, list5, list6 },\n            new [] { list7, list8, list9 },\n            new [] { list7, empty, list9 }\n        }) {\n            var cart = sequenceList.CartesianProduct()\n                .Select(tuple => $\"({string.Join(\", \", tuple)})\");\n            Console.WriteLine($\"{{{string.Join(\", \", cart)}}}\");\n        }\n    }\n}\n\npublic static class Extensions\n{\n    public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences) {\n        IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };\n        return sequences.Aggregate(\n            emptyProduct,\n            (accumulator, sequence) =>\n            from acc in accumulator\n            from item in sequence\n            select acc.Concat(new [] { item }));\n    }\n}"}
{"title": "Casting out nines", "language": "C sharp|C# from Java", "task": "Task   (in three parts):\n\n\n;Part 1\nWrite a procedure (say \\mathit{co9}(x)) which implements Casting Out Nines as described by returning the checksum for x. Demonstrate the procedure using the examples given there, or others you may consider lucky.\n\nNote that this function does nothing more than calculate the least positive residue, modulo 9. Many of the solutions omit Part 1 for this reason. Many languages have a modulo operator, of which this is a trivial application.\n\nWith that understanding, solutions to Part 1, if given, are encouraged to follow the naive pencil-and-paper or mental arithmetic of repeated digit addition understood to be \"casting out nines\", or some approach other than just reducing modulo 9 using a built-in operator. Solutions for part 2 and 3 are not required to make use of the function presented in part 1.\n\n;Part 2\nNotwithstanding past Intel microcode errors, checking computer calculations like this would not be sensible. To find a computer use for your procedure:\n: Consider the statement \"318682 is 101558 + 217124 and squared is 101558217124\" (see: [[Kaprekar numbers#Casting Out Nines (fast)]]).\n: note that 318682 has the same checksum as (101558 + 217124);\n: note that 101558217124 has the same checksum as (101558 + 217124) because for a Kaprekar they are made up of the same digits (sometimes with extra zeroes);\n: note that this implies that for Kaprekar numbers the checksum of k equals the checksum of k^2.\n\nDemonstrate that your procedure can be used to generate or filter a range of numbers with the property \\mathit{co9}(k) = \\mathit{co9}(k^2) and show that this subset is a small proportion of the range and contains all the Kaprekar in the range.\n\n;Part 3\nConsidering this MathWorld page, produce a efficient algorithm based on the more mathematical treatment of Casting Out Nines, and realizing:\n: \\mathit{co9}(x) is the residual of x mod 9;\n: the procedure can be extended to bases other than 9.\n\nDemonstrate your algorithm by generating or filtering a range of numbers with the property k%(\\mathit{Base}-1) == (k^2)%(\\mathit{Base}-1) and show that this subset is a small proportion of the range and contains all the Kaprekar in the range.\n\n;related tasks\n* [[First perfect square in base N with N unique digits]]\n* [[Kaprekar numbers]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace CastingOutNines {\n    public static class Helper {\n        public static string AsString<T>(this IEnumerable<T> e) {\n            var it = e.GetEnumerator();\n\n            StringBuilder builder = new StringBuilder();\n            builder.Append(\"[\");\n\n            if (it.MoveNext()) {\n                builder.Append(it.Current);\n            }\n            while (it.MoveNext()) {\n                builder.Append(\", \");\n                builder.Append(it.Current);\n            }\n\n            builder.Append(\"]\");\n            return builder.ToString();\n        }\n    }\n\n    class Program {\n        static List<int> CastOut(int @base, int start, int end) {\n            int[] ran = Enumerable\n                .Range(0, @base - 1)\n                .Where(a => a % (@base - 1) == (a * a) % (@base - 1))\n                .ToArray();\n            int x = start / (@base - 1);\n\n            List<int> result = new List<int>();\n            while (true) {\n                foreach (int n in ran) {\n                    int k = (@base - 1) * x + n;\n                    if (k < start) {\n                        continue;\n                    }\n                    if (k > end) {\n                        return result;\n                    }\n                    result.Add(k);\n                }\n                x++;\n            }\n        }\n\n        static void Main() {\n            Console.WriteLine(CastOut(16, 1, 255).AsString());\n            Console.WriteLine(CastOut(10, 1, 99).AsString());\n            Console.WriteLine(CastOut(17, 1, 288).AsString());\n        }\n    }\n}"}
{"title": "Catalan numbers/Pascal's triangle", "language": "C sharp|C# from C++", "task": "Print out the first   '''15'''   Catalan numbers by extracting them from Pascal's triangle.\n\n\n;See:\n*   Catalan Numbers and the Pascal Triangle.      This method enables calculation of Catalan Numbers using only addition and subtraction.\n\n*   Catalan's Triangle for a Number Triangle that generates Catalan Numbers using only addition.\n*   Sequence A000108 on OEIS has a lot of information on Catalan Numbers.\n\n;Related Tasks:\n[[Pascal's triangle]]\n\n", "solution": "int n = 15;\nList<int> t = new List<int>() { 0, 1 };\nfor (int i = 1; i <= n; i++)\n{\n    for (var j = i; j > 1; j--) t[j] += t[j - 1];\n    t.Add(t[i]);\n    for (var j = i + 1; j > 1; j--) t[j] += t[j - 1];\n    Console.Write(((i == 1) ? \"\" : \", \") + (t[i + 1] - t[i]));\n}\n"}
{"title": "Catamorphism", "language": "C sharp|C#", "task": "''Reduce'' is a function or method that is used to take the values in an array or a list and apply a function to successive members of the list to produce (or reduce them to), a single value. \n\n\n;Task:\nShow how ''reduce'' (or ''foldl'' or ''foldr'' etc), work (or would be implemented) in your language.\n\n\n;See also:\n* Wikipedia article:   Fold\n* Wikipedia article:   Catamorphism\n\n", "solution": "var nums = Enumerable.Range(1, 10);\n\nint summation = nums.Aggregate((a, b) => a + b);\n\nint product = nums.Aggregate((a, b) => a * b);\n\nstring concatenation = nums.Aggregate(String.Empty, (a, b) => a.ToString() + b.ToString());\n\nConsole.WriteLine(\"{0} {1} {2}\", summation, product, concatenation);"}
{"title": "Chaocipher", "language": "C sharp|C# from D", "task": "Description:\nThe Chaocipher was invented by J.F.Byrne in 1918 and, although simple by modern cryptographic standards, does not appear to have been broken until the algorithm was finally disclosed by his family in 2010.\n\nThe algorithm is described in this paper by M.Rubin in 2010 and there is a C# implementation here.\n\n\n;Task:\nCode the algorithm in your language and to test that it works with the plaintext 'WELLDONEISBETTERTHANWELLSAID' used in the paper itself.\n\n", "solution": "using System;\n\nnamespace Chaocipher {\n    enum Mode {\n        ENCRYPT,\n        DECRYPT,\n    }\n\n    class Program {\n        const string L_ALPHABET = \"HXUCZVAMDSLKPEFJRIGTWOBNYQ\";\n        const string R_ALPHABET = \"PTLNBQDEOYSFAVZKGJRIHWXUMC\";\n\n        static string Exec(string text, Mode mode, bool showSteps = false) {\n            char[] left = L_ALPHABET.ToCharArray();\n            char[] right = R_ALPHABET.ToCharArray();\n            char[] eText = new char[text.Length];\n            char[] temp = new char[26];\n\n            for (int i = 0; i < text.Length; ++i) {\n                if (showSteps) Console.WriteLine(\"{0} {1}\", string.Join(\"\", left), string.Join(\"\", right));\n                int index = 0;\n                if (mode == Mode.ENCRYPT) {\n                    index = Array.IndexOf(right, text[i]);\n                    eText[i] = left[index];\n                } else {\n                    index = Array.IndexOf(left, text[i]);\n                    eText[i] = right[index];\n                }\n                if (i == text.Length - 1) break;\n\n                // permute left\n\n                for (int j = index; j < 26; ++j) temp[j - index] = left[j];\n                for (int j = 0; j < index; ++j) temp[26 - index + j] = left[j];\n                var store = temp[1];\n                for (int j = 2; j < 14; ++j) temp[j - 1] = temp[j];\n                temp[13] = store;\n                temp.CopyTo(left, 0);\n\n                // permute right\n\n                for (int j = index; j < 26; ++j) temp[j - index] = right[j];\n                for (int j = 0; j < index; ++j) temp[26 - index + j] = right[j];\n                store = temp[0];\n                for (int j = 1; j < 26; ++j) temp[j - 1] = temp[j];\n                temp[25] = store;\n                store = temp[2];\n                for (int j = 3; j < 14; ++j) temp[j - 1] = temp[j];\n                temp[13] = store;\n                temp.CopyTo(right, 0);\n            }\n\n            return new string(eText);\n        }\n\n        static void Main(string[] args) {\n            var plainText = \"WELLDONEISBETTERTHANWELLSAID\";\n            Console.WriteLine(\"The original plaintext is : {0}\", plainText);\n            Console.WriteLine(\"\\nThe left and right alphabets after each permutation during encryption are :\\n\");\n            var cipherText = Exec(plainText, Mode.ENCRYPT, true);\n            Console.WriteLine(\"\\nThe ciphertext is : {0}\", cipherText);\n            var plainText2 = Exec(cipherText, Mode.DECRYPT);\n            Console.WriteLine(\"\\nThe recovered plaintext is : {0}\", plainText2);\n        }\n    }\n}"}
{"title": "Chaos game", "language": "C sharp|C#", "task": "The Chaos Game is a method of generating the attractor of an iterated function system (IFS). \n\nOne of the best-known and simplest examples creates a fractal, using a polygon and an initial point selected at random.\n\n\n;Task\nPlay the Chaos Game using the corners of an equilateral triangle as the reference points.   Add a starting point at random (preferably inside the triangle).   Then add the next point halfway between the starting point and one of the reference points.   This reference point is chosen at random.\n\nAfter a sufficient number of iterations, the image of a Sierpinski Triangle should emerge.\n\n\n;See also\n* The Game of Chaos\n\n", "solution": "using System.Diagnostics;\nusing System.Drawing;\n\nnamespace RosettaChaosGame\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            var bm = new Bitmap(600, 600);\n\n            var referencePoints = new Point[] {\n                new Point(0, 600),\n                new Point(600, 600),\n                new Point(300, 81)\n            };\n            var r = new System.Random();\n            var p = new Point(r.Next(600), r.Next(600));\n            for (int count = 0; count < 10000; count++)\n            {\n                bm.SetPixel(p.X, p.Y, Color.Magenta);\n                int i = r.Next(3);\n                p.X = (p.X + referencePoints[i].X) / 2;\n                p.Y = (p.Y + referencePoints[i].Y) / 2;\n            }\n            const string filename = \"Chaos Game.png\";\n            bm.Save(filename);\n            Process.Start(filename);\n        }\n    }\n}"}
{"title": "Check output device is a terminal", "language": "C sharp|C#", "task": "Demonstrate how to check whether the output device is a terminal or not.\n\n\n;Related task:\n*   [[Check input device is a terminal]]\n\n", "solution": "using System;\n\nnamespace CheckTerminal {\n    class Program {\n        static void Main(string[] args) {\n            Console.WriteLine(\"Stdout is tty: {0}\", Console.IsOutputRedirected);\n        }\n    }\n}"}
{"title": "Cheryl's birthday", "language": "C sharp|C#", "task": "Albert and Bernard just became friends with Cheryl, and they want to know when her birthday is.\n\nCheryl gave them a list of ten possible dates:\n      May 15,     May 16,     May 19\n      June 17,    June 18\n      July 14,    July 16\n      August 14,  August 15,  August 17\n\nCheryl then tells Albert the   ''month''   of birth,   and Bernard the   ''day''   (of the month)   of birth.\n  1)  Albert:   I don't know when Cheryl's birthday is, but I know that Bernard does not know too.\n  2)  Bernard:  At first I don't know when Cheryl's birthday is, but I know now.\n  3)  Albert:   Then I also know when Cheryl's birthday is.\n\n\n;Task\nWrite a computer program to deduce, by successive elimination, Cheryl's birthday.\n\n\n;Related task:\n* [[Sum and Product Puzzle]]\n\n\n;References\n* Wikipedia article of the same name.\n* Tuple Relational Calculus\n\n", "solution": "public static class CherylsBirthday\n{\n    public static void Main() {\n        var dates = new HashSet<(string month, int day)> {\n            (\"May\", 15),\n            (\"May\", 16),\n            (\"May\", 19),\n            (\"June\", 17),\n            (\"June\", 18),\n            (\"July\", 14),\n            (\"July\", 16),\n            (\"August\", 14),\n            (\"August\", 15),\n            (\"August\", 17)\n        };\n\n        Console.WriteLine(dates.Count + \" remaining.\");\n        //The month cannot have a unique day.\n        var monthsWithUniqueDays = dates.GroupBy(d => d.day).Where(g => g.Count() == 1).Select(g => g.First().month).ToHashSet();\n        dates.RemoveWhere(d => monthsWithUniqueDays.Contains(d.month));\n        Console.WriteLine(dates.Count + \" remaining.\");\n        //The day must now be unique.\n        dates.IntersectWith(dates.GroupBy(d => d.day).Where(g => g.Count() == 1).Select(g => g.First()));\n        Console.WriteLine(dates.Count + \" remaining.\");\n        //The month must now be unique.\n        dates.IntersectWith(dates.GroupBy(d => d.month).Where(g => g.Count() == 1).Select(g => g.First()));\n        Console.WriteLine(dates.Single());\n    }\n    \n}"}
{"title": "Chinese remainder theorem", "language": "C sharp|C#", "task": "Suppose   n_1,   n_2,   \\ldots,   n_k   are positive [[integer]]s that are pairwise co-prime.   \n\nThen, for any given sequence of integers   a_1,   a_2,   \\dots,   a_k,   there exists an integer   x   solving the following system of simultaneous congruences:\n\n::: \\begin{align}\n  x &\\equiv a_1 \\pmod{n_1} \\\\\n  x &\\equiv a_2 \\pmod{n_2} \\\\\n    &{}\\  \\  \\vdots \\\\\n  x &\\equiv a_k \\pmod{n_k}\n\\end{align}\n\nFurthermore, all solutions   x   of this system are congruent modulo the product,    N=n_1n_2\\ldots n_k.\n\n\n;Task:\nWrite a program to solve a system of linear congruences by applying the   Chinese Remainder Theorem. \n\nIf the system of equations cannot be solved, your program must somehow indicate this. \n\n(It may throw an exception or return a special false value.) \n\nSince there are infinitely many solutions, the program should return the unique solution   s   where   0 \\leq s \\leq n_1n_2\\ldots n_k.\n\n\n''Show the functionality of this program'' by printing the result such that the   n's   are   [3,5,7]   and the   a's   are   [2,3,2].\n\n\n'''Algorithm''':   The following algorithm only applies if the   n_i's   are pairwise co-prime. \n\nSuppose, as above, that a solution is required for the system of congruences:\n\n::: x \\equiv a_i \\pmod{n_i} \\quad\\mathrm{for}\\; i = 1, \\ldots, k\n\nAgain, to begin, the product   N = n_1n_2 \\ldots n_k   is defined. \n\nThen a solution   x   can be found as follows:\n\nFor each   i,   the integers   n_i   and   N/n_i   are co-prime. \n\nUsing the   Extended Euclidean algorithm,   we can find integers   r_i   and   s_i   such that   r_i n_i + s_i N/n_i = 1. \n\nThen, one solution to the system of simultaneous congruences is:\n\n::: x = \\sum_{i=1}^k a_i s_i N/n_i\n\nand the minimal solution,\n\n::: x \\pmod{N}.\n\n", "solution": "using System;\nusing System.Linq;\n\nnamespace ChineseRemainderTheorem\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            int[] n = { 3, 5, 7 };\n            int[] a = { 2, 3, 2 };\n\n            int result = ChineseRemainderTheorem.Solve(n, a);\n\n            int counter = 0;\n            int maxCount = n.Length - 1;\n            while (counter <= maxCount)\n            {\n                Console.WriteLine($\"{result} \u2261 {a[counter]} (mod {n[counter]})\");\n                counter++;\n            }\n        }\n    }\n\n    public static class ChineseRemainderTheorem\n    {\n        public static int Solve(int[] n, int[] a)\n        {\n            int prod = n.Aggregate(1, (i, j) => i * j);\n            int p;\n            int sm = 0;\n            for (int i = 0; i < n.Length; i++)\n            {\n                p = prod / n[i];\n                sm += a[i] * ModularMultiplicativeInverse(p, n[i]) * p;\n            }\n            return sm % prod;\n        }\n\n        private static int ModularMultiplicativeInverse(int a, int mod)\n        {\n            int b = a % mod;\n            for (int x = 1; x < mod; x++)\n            {\n                if ((b * x) % mod == 1)\n                {\n                    return x;\n                }\n            }\n            return 1;\n        }\n    }\n}"}
{"title": "Chinese zodiac", "language": "C sharp|C# from Java", "task": "Determine the Chinese zodiac sign and related associations for a given year.\nTraditionally, the Chinese have counted years using two lists of labels, one of length 10 (the \"celestial stems\") and one of length 12 (the \"terrestrial branches\"). The labels do not really have any meaning outside their positions in the two lists; they're simply a traditional enumeration device, used much as Westerners use letters and numbers. They were historically used for months and days as well as years, and the stems are still sometimes used for school grades.\n\nYears cycle through both lists concurrently, so that both stem and branch advance each year; if we used Roman letters for the stems and numbers for the branches, consecutive years would be labeled A1, B2, C3, etc. Since the two lists are different lengths, they cycle back to their beginning at different points: after J10 we get A11, and then after B12 we get C1. The result is a repeating 60-year pattern within which each pair of names occurs only once.\n\nMapping the branches to twelve traditional animal deities results in the well-known \"Chinese zodiac\", assigning each year to a given animal. For example, Sunday, January 22, 2023 CE (in the common Gregorian calendar) began the lunisolar Year of the Rabbit.\n\nThe celestial stems do not have a one-to-one mapping like that of the branches to animals; however, the five pairs of consecutive stems are each associated with one of the five traditional Chinese elements (Wood, Fire, Earth, Metal, and Water). Further, one of the two years within each element is assigned to yin, the other to yang.\n\nThus, the Chinese year beginning in 2023 CE is also the yin year of Water. Since 12 is an even number, the association between animals and yin/yang doesn't change; consecutive Years of the Rabbit will cycle through the five elements, but will always be yin.\n\n;Task: Create a subroutine or program that will return or output the animal, yin/yang association, and element for the lunisolar year that begins in a given CE year.\n\nYou may optionally provide more information in the form of the year's numerical position within the 60-year cycle and/or its actual Chinese stem-branch name (in Han characters or Pinyin transliteration).\n\n;Requisite information:\n* The animal cycle runs in this order: Rat, Ox, Tiger, Rabbit, Dragon, Snake, Horse, Goat, Monkey, Rooster, Dog, Pig.\n* The element cycle runs in this order: Wood, Fire, Earth, Metal, Water. \n* Each element gets two consecutive years; a yang followed by a yin.\n* The current 60-year cycle began in 1984; any multiple of 60 years from that point may be used to reckon from.\n\nThus, year 1 of a cycle is the year of the Wood Rat (yang), year 2 the Wood Ox (yin), and year 3 the Fire Tiger (yang). The year 2023 - which, as already noted, is the year of the Water Rabbit (yin) - is the 40th year of the current cycle. \n\n;Information for optional task:\n* The ten celestial stems are '''Jia ''' ''jia'', '''Yi ''' ''yi'', '''Bing ''' ''bing'', '''Ding ''' ''ding'', '''Wu ''' ''wu'', '''Ji ''' ''ji'', '''Geng ''' ''geng'', '''Xin ''' ''xin'', '''Ren ''' ''ren'', and '''Gui ''' ''gui''. With the ASCII version of Pinyin tones, the names are written \"jia3\", \"yi3\", \"bing3\", \"ding1\", \"wu4\", \"ji3\", \"geng1\", \"xin1\", \"ren2\", and \"gui3\".\n* The twelve terrestrial branches are '''Zi ''' ''zi'', '''Chou ''' ''chou'', '''Yin ''' ''yin'', '''Mao ''' ''mao'', '''Chen ''' ''chen'', '''Si ''' ''si'', '''Wu ''' ''wu'', '''Wei ''' ''wei'', '''Shen ''' ''shen'', '''You ''' ''you'', '''Xu ''' ''xu'', '''Hai ''' ''hai''. In ASCII Pinyin, those are \"zi3\", \"chou3\", \"yin2\", \"mao3\", \"chen2\", \"si4\", \"wu3\", \"wei4\", \"shen1\", \"you3\", \"xu1\", and \"hai4\".\n\nTherefore 1984 was '''Jia Zi ''' (''jia-zi'', or jia3-zi3).  2023 is '''Gui Mao ''' (''gui-mao'' or gui3-mao3).\n", "solution": "using System;\n\nnamespace ChineseZodiac {\n    class Program {\n        static string[] animals = { \"Rat\", \"Ox\", \"Tiger\", \"Rabbit\", \"Dragon\", \"Snake\", \"Horse\", \"Goat\", \"Monkey\", \"Rooster\", \"Dog\", \"Pig\" };\n        static string[] elements = { \"Wood\", \"Fire\", \"Earth\", \"Metal\", \"Water\" };\n        static string[] animalChars = { \"\u5b50\", \"\u4e11\", \"\u5bc5\", \"\u536f\", \"\u8fb0\", \"\u5df3\", \"\u5348\", \"\u672a\", \"\u7533\", \"\u9149\", \"\u620c\", \"\u4ea5\" };\n        static string[,] elementChars = { { \"\u7532\", \"\u4e19\", \"\u620a\", \"\u5e9a\", \"\u58ec\" }, { \"\u4e59\", \"\u4e01\", \"\u5df1\", \"\u8f9b\", \"\u7678\" } };\n\n        static string getYY(int year) {\n            if (year % 2 == 0) {\n                return \"yang\";\n            }\n            return \"yin\";\n        }\n\n        static void Main(string[] args) {\n            Console.OutputEncoding = System.Text.Encoding.UTF8;\n            int[] years = { 1935, 1938, 1968, 1972, 1976, 1984, 1985, 2017 };\n            for (int i = 0; i < years.Length; i++) {\n                int ei = (int)Math.Floor((years[i] - 4.0) % 10 / 2);\n                int ai = (years[i] - 4) % 12;\n                Console.WriteLine(\"{0} is the year of the {1} {2} ({3}). {4}{5}\", years[i], elements[ei], animals[ai], getYY(years[i]), elementChars[years[i] % 2, ei], animalChars[(years[i] - 4) % 12]);\n            }\n        }\n    }\n}"}
{"title": "Church numerals", "language": "C sharp|C#", "task": "In the Church encoding of natural numbers, the number N is encoded by a function that applies its first argument N times to its second argument.\n\n* '''Church zero''' always returns the identity function, regardless of its first argument. In other words, the first argument is not applied to the second argument at all.\n* '''Church one''' applies its first argument f just once to its second argument x, yielding '''f(x)'''\n* '''Church two''' applies its first argument f twice to its second argument x, yielding '''f(f(x))'''\n* and each successive Church numeral applies its first argument one additional time to its second argument, '''f(f(f(x)))''', '''f(f(f(f(x))))''' ...  The Church numeral 4, for example, returns a quadruple composition of the function supplied as its first argument.\n\n\nArithmetic operations on natural numbers can be similarly represented as functions on Church numerals.\n\nIn your language define:\n\n* Church Zero,\n* a Church successor function (a function on a Church numeral which returns the next Church numeral in the series),\n* functions for Addition, Multiplication and Exponentiation over Church numerals,\n* a function to convert integers to corresponding Church numerals,\n* and a function to convert Church numerals to corresponding integers.\n\n\nYou should:\n\n* Derive Church numerals three and four in terms of Church zero and a Church successor function.\n* use Church numeral arithmetic to obtain the the sum and the product of Church 3 and Church 4,\n* similarly obtain 4^3 and 3^4 in terms of Church numerals, using a Church numeral exponentiation function,\n* convert each result back to an integer, and return it or print it to the console.\n\n\n", "solution": "using System;\n \npublic delegate Church Church(Church f);\n \npublic static class ChurchNumeral\n{\n    public static readonly Church ChurchZero = _ => x => x;\n    public static readonly Church ChurchOne = f => f;\n \n    public static Church Successor(this Church n) => f => x => f(n(f)(x));\n    public static Church Add(this Church m, Church n) => f => x => m(f)(n(f)(x));\n    public static Church Multiply(this Church m, Church n) => f => m(n(f));\n    public static Church Exponent(this Church m, Church n) => n(m);\n    public static Church IsZero(this Church n) => n(_ => ChurchZero)(ChurchOne);\n    public static Church Predecessor(this Church n) =>\n      f => x => n(g => h => h(g(f)))(_ => x)(a => a);\n    public static Church Subtract(this Church m, Church n) => n(Predecessor)(m);\n    static Church looper(this Church v, Church d) =>\n        v(_ => v.divr(d).Successor())(ChurchZero);\n    static Church divr(this Church n, Church d) =>\n        n.Subtract(d).looper(d);\n    public static Church Divide(this Church dvdnd, Church dvsr) =>\n        (dvdnd.Successor()).divr(dvsr);\n \n    public static Church FromInt(int i) =>\n      i <= 0 ? ChurchZero : Successor(FromInt(i - 1));\n \n    public static int ToInt(this Church ch) {\n        int count = 0;\n        ch(x => { count++; return x; })(null);\n        return count;\n    }\n \n    public static void Main() {\n        Church c3 = FromInt(3);\n        Church c4 = c3.Successor();\n        Church c11 = FromInt(11);\n        Church c12 = c11.Successor();\n        int sum = c3.Add(c4).ToInt();\n        int product = c3.Multiply(c4).ToInt();\n        int exp43 = c4.Exponent(c3).ToInt();\n        int exp34 = c3.Exponent(c4).ToInt();\n        int tst0 = ChurchZero.IsZero().ToInt();\n        int pred4 = c4.Predecessor().ToInt();\n        int sub43 = c4.Subtract(c3).ToInt();\n        int div11by3 = c11.Divide(c3).ToInt();\n        int div12by3 = c12.Divide(c3).ToInt();\n        Console.Write($\"{sum} {product} {exp43} {exp34} {tst0} \");\n        Console.WriteLine($\"{pred4} {sub43} {div11by3} {div12by3}\");\n    } \n}"}
{"title": "Circles of given radius through two points", "language": "C sharp 6", "task": "2 circles with a given radius through 2 points in 2D space.\n\nGiven two points on a plane and a radius, usually two circles of given radius can be drawn through the points. \n;Exceptions:\n# r==0.0 should be treated as never describing circles (except in the case where the points are coincident).\n# If the points are coincident then an infinite number of circles with the point on their circumference can be drawn, unless r==0.0 as well which then collapses the circles to a point.\n# If the points form a diameter then return two identical circles ''or'' return a single circle, according to which is the most natural mechanism for the implementation language.\n# If the points are too far apart then no circles can be drawn.\n\n\n;Task detail:\n* Write a function/subroutine/method/... that takes two points and a radius and returns the two circles through those points, ''or some indication of special cases where two, possibly equal, circles cannot be returned''.\n* Show here the output for the following inputs:\n\n      p1                p2           r\n0.1234, 0.9876    0.8765, 0.2345    2.0\n0.0000, 2.0000    0.0000, 0.0000    1.0\n0.1234, 0.9876    0.1234, 0.9876    2.0\n0.1234, 0.9876    0.8765, 0.2345    0.5\n0.1234, 0.9876    0.1234, 0.9876    0.0\n\n\n\n;Related task:\n*   [[Total circles area]].\n\n\n;See also:\n*   Finding the Center of a Circle from 2 Points and Radius from Math forum @ Drexel\n\n", "solution": "using System;\npublic class CirclesOfGivenRadiusThroughTwoPoints\n{\n    public static void Main()\n    {\n        double[][] values = new double[][] {\n            new [] { 0.1234, 0.9876, 0.8765, 0.2345,   2 },\n            new [] { 0.0,       2.0,    0.0,    0.0,   1 },\n            new [] { 0.1234, 0.9876, 0.1234, 0.9876,   2 },\n            new [] { 0.1234, 0.9876, 0.8765, 0.2345, 0.5 },\n            new [] { 0.1234, 0.9876, 0.1234, 0.9876,   0 }\n        };\n\t\t\n        foreach (var a in values) {\n            var p = new Point(a[0], a[1]);\n            var q = new Point(a[2], a[3]);\n            Console.WriteLine($\"Points {p} and {q} with radius {a[4]}:\");\n            try {\n                var centers = FindCircles(p, q, a[4]);\n                Console.WriteLine(\"\\t\" + string.Join(\" and \", centers));\n            } catch (Exception ex) {\n                Console.WriteLine(\"\\t\" + ex.Message);\n            }\n        }\n    }\n\t\n    static Point[] FindCircles(Point p, Point q, double radius) {\n        if(radius < 0) throw new ArgumentException(\"Negative radius.\");\n        if(radius == 0) {\n            if(p == q) return new [] { p };\n            else throw new InvalidOperationException(\"No circles.\");\n        }\n        if (p == q) throw new InvalidOperationException(\"Infinite number of circles.\");\n\t\t\n        double sqDistance = Point.SquaredDistance(p, q);\n        double sqDiameter = 4 * radius * radius;\n        if (sqDistance > sqDiameter) throw new InvalidOperationException(\"Points are too far apart.\");\n\t\t\n        Point midPoint = new Point((p.X + q.X) / 2, (p.Y + q.Y) / 2);\n        if (sqDistance == sqDiameter) return new [] { midPoint };\n\t\t\n        double d = Math.Sqrt(radius * radius - sqDistance / 4);\n        double distance = Math.Sqrt(sqDistance);\n        double ox = d * (q.X - p.X) / distance, oy = d * (q.Y - p.Y) / distance;\n        return new [] {\n            new Point(midPoint.X - oy, midPoint.Y + ox),\n            new Point(midPoint.X + oy, midPoint.Y - ox)\n        };\n    }\n\t\n    public struct Point\n    {\n        public Point(double x, double y) : this() {\n            X = x;\n            Y = y;\n        }\n\t\n        public double X { get; }\n        public double Y { get; }\n\t\n        public static bool operator ==(Point p, Point q) => p.X == q.X && p.Y == q.Y;\n        public static bool operator !=(Point p, Point q) => p.X != q.X || p.Y != q.Y;\n\t\n        public static double SquaredDistance(Point p, Point q) {\n            double dx = q.X - p.X, dy = q.Y - p.Y;\n            return dx * dx + dy * dy;\n        }\n\t\t\n        public override string ToString() => $\"({X}, {Y})\";\n\t\t\n    }\t\n}"}
{"title": "Closures/Value capture", "language": "C sharp|C#", "task": "Create a list of ten functions, in the simplest manner possible   (anonymous functions are encouraged),   such that the function at index   '' i ''    (you may choose to start    '' i ''    from either    '''0'''    or    '''1'''),     when run, should return the square of the index,   that is,    '' i '' 2. \n\nDisplay the result of running any but the last function, to demonstrate that the function indeed remembers its value.\n\n\n;Goal:\nDemonstrate how to create a series of independent closures based on the same template but maintain separate copies of the variable closed over. \n\nIn imperative languages, one would generally use a loop with a mutable counter variable. \n\nFor each function to maintain the correct number, it has to capture the ''value'' of the variable at the time it was created, rather than just a reference to the variable, which would have a different value by the time the function was run.\n\nSee also: [[Multiple distinct objects]]\n", "solution": "using System;\nusing System.Linq;\n\nclass Program\n{\n    static void Main()\n    {\n        var captor = (Func<int, Func<int>>)(number => () => number * number);\n        var functions = Enumerable.Range(0, 10).Select(captor);\n        foreach (var function in functions.Take(9))\n        {\n            Console.WriteLine(function());\n        }\n    }\n}"}
{"title": "Comma quibbling", "language": "C sharp|C#", "task": "Comma quibbling is a task originally set by Eric Lippert in his blog.\n\n\n;Task:\n\nWrite a function to generate a string output which is the concatenation of input words from a list/sequence where:\n# An input of no words produces the output string of just the two brace characters \"{}\".\n# An input of just one word, e.g. [\"ABC\"], produces the output string of the word inside the two braces, e.g. \"{ABC}\".\n# An input of two words, e.g. [\"ABC\", \"DEF\"], produces the output string of the two words inside the two braces with the words separated by the string \" and \", e.g. \"{ABC and DEF}\".\n# An input of three or more words, e.g. [\"ABC\", \"DEF\", \"G\", \"H\"], produces the output string of all but the last word separated by \", \" with the last word separated by \" and \" and all within braces; e.g. \"{ABC, DEF, G and H}\".\n\n\nTest your function with the following series of inputs showing your output here on this page:\n* []                       # (No input words).\n* [\"ABC\"]\n* [\"ABC\", \"DEF\"]\n* [\"ABC\", \"DEF\", \"G\", \"H\"]\n\n\nNote: Assume words are non-empty strings of uppercase characters for this task.\n\n", "solution": "using System;\nusing System.Linq;\n\nnamespace CommaQuibbling\n{\n    internal static class Program\n    {\n        #region Static Members\n\tprivate static string Quibble(string[] input)\n\t{\n            return\n                String.Format(\"{{{0}}}\",\n                    String.Join(\"\",\n                        input.Reverse().Zip(\n                            new [] { \"\", \" and \" }.Concat(Enumerable.Repeat(\", \", int.MaxValue)),\n                            (x, y) => x + y).Reverse()));\n\t}\n\n\n        private static void Main()\n        {\n            Console.WriteLine( Quibble( new string[] {} ) );\n            Console.WriteLine( Quibble( new[] {\"ABC\"} ) );\n            Console.WriteLine( Quibble( new[] {\"ABC\", \"DEF\"} ) );\n            Console.WriteLine( Quibble( new[] {\"ABC\", \"DEF\", \"G\", \"H\"} ) );\n\n            Console.WriteLine( \"< Press Any Key >\" );\n            Console.ReadKey();\n        }\n\n        #endregion\n    }\n}"}
{"title": "Command-line arguments", "language": "C sharp|C#", "task": "{{selection|Short Circuit|Console Program Basics}} Retrieve the list of command-line arguments given to the program. For programs that only print the arguments when run directly, see [[Scripted main]].\nSee also [[Program name]].\n\nFor parsing command line arguments intelligently, see [[Parsing command-line arguments]].\n\nExample command line:\n\n myprogram -c \"alpha beta\" -h \"gamma\"\n\n", "solution": "using System;\n\nnamespace RosettaCode {\n    class Program {\n        static void Main() {\n            string[] args = Environment.GetCommandLineArgs();\n            for (int i = 0; i < args.Length; i++)\n                Console.WriteLine(String.Format(\"Argument {0} is '{1}'\", i, args[i]));\n        }\n    }\n}"}
{"title": "Compare a list of strings", "language": "C sharp 7", "task": "Given a   list   of arbitrarily many strings, show how to:\n\n*   test if they are all lexically '''equal'''\n*   test if every string is lexically '''less than''' the one after it  ''(i.e. whether the list is in strict ascending order)''\n\n\nEach of those two tests should result in a single true or false value, which could be used as the condition of an    if    statement or similar. \n\nIf the input list has less than two elements, the tests should always return true.\n\nThere is ''no'' need to provide a complete program and output.\n \nAssume that the strings are already stored in an array/list/sequence/tuple variable (whatever is most idiomatic) with the name   strings,   and just show the expressions for performing those two tests on it (plus of course any includes and custom functions etc. that it needs),   with as little distractions as possible.\n\nTry to write your solution in a way that does not modify the original list,   but if it does then please add a note to make that clear to readers.\n\nIf you need further guidance/clarification,   see [[#Perl]] and [[#Python]] for solutions that use implicit short-circuiting loops,   and [[#Raku]] for a solution that gets away with simply using a built-in language feature. \n\n", "solution": "public static (bool lexicallyEqual, bool strictlyAscending) CompareAListOfStrings(List<string> strings) =>\n    strings.Count < 2 ? (true, true) :\n    (\n        strings.Distinct().Count() < 2,\n        Enumerable.Range(1, strings.Count - 1).All(i => string.Compare(strings[i-1], strings[i]) < 0)\n    );"}
{"title": "Compile-time calculation", "language": "C sharp|C#", "task": "Some programming languages allow calculation of values at compile time. \n\n\n;Task:\nCalculate    10!    (ten factorial)   at compile time. \n\nPrint the result when the program is run.\n\nDiscuss what limitations apply to compile-time calculations in your language.\n\n", "solution": "using System;\n\npublic static class Program\n{\n    public const int FACTORIAL_10 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1;\n    static void Main()\n    {\n        Console.WriteLine(FACTORIAL_10);\n    }\n}"}
{"title": "Compiler/lexical analyzer", "language": "C sharp|C#", "task": "The C and Python versions can be considered reference implementations.\n\n\n;Related Tasks\n* Syntax Analyzer task\n* Code Generator task\n* Virtual Machine Interpreter task\n* AST Interpreter task\n\n\n", "solution": "using System;\nusing System.IO;\nusing System.Linq;\nusing System.Collections.Generic;\n\n\nnamespace Rosetta {\n\n    public enum TokenType {\n        End_of_input, Op_multiply, Op_divide, Op_mod, Op_add, Op_subtract,\n        Op_negate, Op_not, Op_less, Op_lessequal, Op_greater, Op_greaterequal,\n        Op_equal, Op_notequal, Op_assign, Op_and, Op_or, Keyword_if,\n        Keyword_else, Keyword_while, Keyword_print, Keyword_putc, LeftParen, RightParen,\n        LeftBrace, RightBrace, Semicolon, Comma, Identifier, Integer, String, None\n    }\n\n    /// <summary>\n    /// Storage class for tokens\n    /// </summary>\n    public class Token {\n        public TokenType Type { get; set; }\n        public int Line { get; set; }\n        public int Position { get; set; }\n        public string Value { get; set; }\n        public override string ToString() {\n            if (Type == TokenType.Integer || Type == TokenType.Identifier) {\n                return String.Format(\"{0,-5}  {1,-5}   {2,-14}     {3}\", Line, Position, Type.ToString(), Value);\n            } else if (Type == TokenType.String) {\n                return String.Format(\"{0,-5}  {1,-5}   {2,-14}     \\\"{3}\\\"\", Line, Position, Type.ToString(), Value.Replace(\"\\n\", \"\\\\n\"));\n            }\n            return String.Format(\"{0,-5}  {1,-5}   {2,-14}\", Line, Position, Type.ToString());\n        }\n    }\n\n    /// <summary>\n    /// C# Example of Lexical scanner for Rosetta Compiler\n    /// </summary>\n    public class LexicalScanner {\n\n        // character classes \n        private const string _letters = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_\";        \n        private const string _numbers = \"0123456789\";\n        private const string _identifier = _letters + _numbers + \"_\";\n        private const string _whitespace = \" \\t\\n\\r\";\n        \n        // mappings from string keywords to token type \n        private Dictionary<string, TokenType> _keywordTokenTypeMap = new Dictionary<string, TokenType>() {\n            { \"if\", TokenType.Keyword_if },\n            { \"else\", TokenType.Keyword_else },\n            { \"while\", TokenType.Keyword_while },\n            { \"print\", TokenType.Keyword_print },\n            { \"putc\", TokenType.Keyword_putc }\n        };\n\n        // mappings from simple operators to token type\n        private Dictionary<string, TokenType> _operatorTokenTypeMap = new Dictionary<string, TokenType>() {\n            { \"+\", TokenType.Op_add },\n            { \"-\", TokenType.Op_subtract },\n            { \"*\", TokenType.Op_multiply },\n            { \"/\", TokenType.Op_divide },\n            { \"%\", TokenType.Op_mod },\n            { \"=\", TokenType.Op_assign },\n            { \"<\", TokenType.Op_less },\n            { \">\", TokenType.Op_greater },\n            { \"!\", TokenType.Op_not },\n        };\n\n        private List<string> _keywords;\n        private string _operators = \"+-*/%=<>!%\";\n\n        private string _code;\n        private List<Token> tokens = new List<Token>();\n\n        private int _line = 1;\n        private int _position = 1;\n\n        public string CurrentCharacter {\n            get {\n                try {\n                    return _code.Substring(0, 1);\n                } catch (ArgumentOutOfRangeException) {\n                    return \"\";\n                }\n            }\n        }\n\n        /// <summary>\n        /// Lexical scanner initialiser\n        /// </summary>\n        /// <param name=\"code\">Code to be tokenised</param>\n        public LexicalScanner (string code) {\n            _code = code;\n            _keywords = _keywordTokenTypeMap.Keys.ToList();\n        }\n\n        /// <summary>\n        /// Advance the cursor forward given number of characters\n        /// </summary>\n        /// <param name=\"characters\">Number of characters to advance</param>\n        private void advance(int characters=1) {\n            try {\n                // reset position when there is a newline\n                if (CurrentCharacter == \"\\n\") {\n                    _position = 0;\n                    _line++;\n                }\n                    \n                _code = _code.Substring(characters, _code.Length - characters);\n                _position += characters;\n            } catch (ArgumentOutOfRangeException) {\n                _code = \"\";\n            }\n        }\n\n        /// <summary>\n        /// Outputs error message to the console and exits \n        /// </summary>\n        /// <param name=\"message\">Error message to display to user</param>\n        /// <param name=\"line\">Line error occurred on</param>\n        /// <param name=\"position\">Line column that the error occurred at</param>\n        public void error(string message, int line, int position) {\n            // output error to the console and exit\n            Console.WriteLine(String.Format(\"{0} @ {1}:{2}\", message, line, position));\n            Environment.Exit(1);\n        }\n\n        /// <summary>\n        /// Pattern matching using first & follow matching\n        /// </summary>\n        /// <param name=\"recogniseClass\">String of characters that identifies the token type\n        /// or the exact match the be made if exact:true</param>\n        /// <param name=\"matchClass\">String of characters to match against remaining target characters</param>\n        /// <param name=\"tokenType\">Type of token the match represents.</param>\n        /// <param name=\"notNextClass\">Optional class of characters that cannot follow the match</param>\n        /// <param name=\"maxLen\">Optional maximum length of token value</param>\n        /// <param name=\"exact\">Denotes whether recogniseClass represents an exact match or class match. \n        /// Default: false</param>\n        /// <param name=\"discard\">Denotes whether the token is kept or discarded. Default: false</param>\n        /// <param name=\"offset\">Optiona line position offset to account for discarded tokens</param>\n        /// <returns>Boolean indicating if a match was made </returns>\n        public bool match(string recogniseClass, string matchClass, TokenType tokenType, \n                          string notNextClass=null, int maxLen=Int32.MaxValue, bool exact=false, \n                          bool discard=false, int offset=0) {\n\n            // if we've hit the end of the file, there's no more matching to be done\n            if (CurrentCharacter == \"\")\n                return false;\n\n            // store _current_ line and position so that our vectors point at the start\n            // of each token\n            int line = _line;\n            int position = _position;\n\n            // special case exact tokens to avoid needing to worry about backtracking\n            if (exact) {\n                if (_code.StartsWith(recogniseClass)) {\n                    if (!discard) \n                        tokens.Add(new Token() { Type = tokenType, Value = recogniseClass, Line = line, Position = position - offset});   \n                    advance(recogniseClass.Length);\n                    return true;\n                }\n                return false;\n            }\n\n            // first match - denotes the token type usually\n            if (!recogniseClass.Contains(CurrentCharacter))\n                return false;\n\n            string tokenValue = CurrentCharacter;\n            advance();\n\n            // follow match while we haven't exceeded maxLen and there are still characters\n            // in the code stream\n            while ((matchClass ?? \"\").Contains(CurrentCharacter) && tokenValue.Length <= maxLen && CurrentCharacter != \"\") {\n                tokenValue += CurrentCharacter;\n                advance();\n            }\n\n            // ensure that any incompatible characters are not next to the token\n            // eg 42fred is invalid, and neither recognized as a number nor an identifier.\n            // _letters would be the notNextClass\n            if (notNextClass != null && notNextClass.Contains(CurrentCharacter))\n                error(\"Unrecognised character: \" + CurrentCharacter, _line, _position);\n\n            // only add tokens to the stack that aren't marked as discard - dont want\n            // things like open and close quotes/comments\n            if (!discard) {\n                Token token = new Token() { Type = tokenType, Value = tokenValue, Line = line, Position = position - offset };\n                tokens.Add(token);\n            }\n\n            return true;\n        }\n\n        /// <summary>\n        /// Tokenise the input code \n        /// </summary>\n        /// <returns>List of Tokens</returns>\n        public List<Token> scan() {\n\n            while (CurrentCharacter != \"\") {\n                // match whitespace\n                match(_whitespace, _whitespace, TokenType.None, discard: true);\n\n                // match integers\n                match(_numbers, _numbers, TokenType.Integer, notNextClass:_letters);\n                \n                // match identifiers and keywords\n                if (match(_letters, _identifier, TokenType.Identifier)) {\n                    Token match = tokens.Last();\n                    if (_keywords.Contains(match.Value))\n                        match.Type = _keywordTokenTypeMap[match.Value];\n                }\n\n                // match string similarly to comments without allowing newlines\n                // this token doesn't get discarded though\n                if (match(\"\\\"\", null, TokenType.String, discard:true)) {\n                    string value = \"\";\n                    int position = _position;\n                    while (!match(\"\\\"\", null, TokenType.String, discard:true)) {\n                        // not allowed newlines in strings\n                        if (CurrentCharacter == \"\\n\")\n                            error(\"End-of-line while scanning string literal. Closing string character not found before end-of-line\", _line, _position);\n                        // end of file reached before finding end of string\n                        if (CurrentCharacter == \"\")\n                            error(\"End-of-file while scanning string literal. Closing string character not found\", _line, _position);\n\n                        value += CurrentCharacter;\n\n                        // deal with escape sequences - we only accept newline (\\n)\n                        if (value.Length >= 2) {\n                            string lastCharacters = value.Substring(value.Length - 2, 2);\n                            if (lastCharacters[0] == '\\\\') {\n                                if (lastCharacters[1] != 'n') {\n                                    error(\"Unknown escape sequence. \", _line, position);\n                                }\n                                value = value.Substring(0, value.Length - 2).ToString() + \"\\n\";\n                            }\n                        }\n\n                        advance();\n                    }\n                    tokens.Add(new Token() { Type = TokenType.String, Value = value, Line = _line, Position = position - 1});\n                }\n\n                // match string literals\n                if (match(\"'\", null, TokenType.Integer, discard:true)) {\n                    int value;\n                    int position = _position;\n                    value = CurrentCharacter.ToCharArray()[0];\n                    advance();\n\n                    // deal with empty literals ''\n                    if (value == '\\'')\n                        error(\"Empty character literal\", _line, _position);\n\n                    // deal with escaped characters, only need to worry about \\n and \\\\\n                    // throw werror on any other\n                    if (value == '\\\\') {\n                        if (CurrentCharacter == \"n\") {\n                            value = '\\n';\n                        } else if (CurrentCharacter == \"\\\\\") {\n                            value = '\\\\';\n                        } else {\n                            error(\"Unknown escape sequence. \", _line, _position - 1);\n                        }\n                        advance();\n                    }\n\n                    // if we haven't hit a closing ' here, there are two many characters\n                    // in the literal\n                    if (!match(\"'\", null, TokenType.Integer, discard: true))\n                        error(\"Multi-character constant\", _line, _position);\n\n                    tokens.Add(new Rosetta.Token() { Type = TokenType.Integer, Value = value.ToString(), Line = _line, Position = position - 1 });\n                }\n\n                // match comments by checking for starting token, then advancing \n                // until closing token is matched\n                if (match(\"/*\", null, TokenType.None, exact: true, discard: true)) {\n                    while (!match(\"*/\", null, TokenType.None, exact: true, discard: true)) {\n                        // reached the end of the file without closing comment!\n                        if (CurrentCharacter == \"\")\n                            error(\"End-of-file in comment. Closing comment characters not found.\", _line, _position);\n                        advance();\n                    }\n                    continue;\n                }\n\n                // match complex operators\n                match(\"<=\", null, TokenType.Op_lessequal, exact: true);\n                match(\">=\", null, TokenType.Op_greaterequal, exact: true);\n                match(\"==\", null, TokenType.Op_equal, exact: true);\n                match(\"!=\", null, TokenType.Op_notequal, exact: true);\n                match(\"&&\", null, TokenType.Op_and, exact: true);\n                match(\"||\", null, TokenType.Op_or, exact: true);\n\n                // match simple operators\n                if (match(_operators, null, TokenType.None, maxLen:1)) {\n                    Token match = tokens.Last();\n                    match.Type = _operatorTokenTypeMap[match.Value];\n                }\n\n                // brackets, braces and separators\n                match(\"(\", null, TokenType.LeftParen, exact: true);\n                match(\")\", null, TokenType.RightParen, exact: true);\n                match(\"{\", null, TokenType.LeftBrace, exact: true);\n                match(\"}\", null, TokenType.RightBrace, exact: true);\n                match(\";\", null, TokenType.Semicolon, exact: true);\n                match(\",\", null, TokenType.Comma, exact: true);\n\n            }\n\n            // end of file token\n            tokens.Add(new Rosetta.Token() { Type = TokenType.End_of_input, Line = _line, Position = _position });\n            \n            return tokens;\n        }\n\n        static void Main (string[] args) {\n            StreamReader inputFile;\n\n            // if we passed in a filename, read code from that, else\n            // read code from stdin\n            if (args.Length > 0) {\n                string path = args[0];\n                try {\n                    inputFile = new StreamReader(path);\n                } catch (IOException) {\n                    inputFile = new StreamReader(Console.OpenStandardInput(8192));\n                }\n            } else {\n                inputFile = new StreamReader(Console.OpenStandardInput(8192));\n            }\n\n            string code = inputFile.ReadToEnd();\n\n            // strip windows line endings out\n            code = code.Replace(\"\\r\", \"\");\n\n            LexicalScanner scanner = new LexicalScanner(code);\n            List<Token> tokens = scanner.scan();\n\n            foreach(Token token in tokens) {\n                Console.WriteLine(token.ToString());\n            }       \n        }\n    }\n}\n"}
{"title": "Continued fraction", "language": "C sharp|C# from Java", "task": "A number may be represented as a continued fraction (see Mathworld for more information) as follows:\n:a_0 + \\cfrac{b_1}{a_1 + \\cfrac{b_2}{a_2 + \\cfrac{b_3}{a_3 + \\ddots}}}\n\nThe task is to write a program which generates such a number and prints a real representation of it. The code should be tested by calculating and printing the square root of 2, Napier's Constant, and Pi, using the following coefficients:\n\nFor the square root of 2, use a_0 = 1 then a_N = 2. b_N is always 1.\n\n:\\sqrt{2} = 1 + \\cfrac{1}{2 + \\cfrac{1}{2 + \\cfrac{1}{2 + \\ddots}}}\n\nFor Napier's Constant, use a_0 = 2, then a_N = N. b_1 = 1 then b_N = N-1.\n\n:e = 2 + \\cfrac{1}{1 + \\cfrac{1}{2 + \\cfrac{2}{3 + \\cfrac{3}{4 + \\ddots}}}}\n\nFor Pi, use a_0 = 3 then a_N = 6. b_N = (2N-1)^2.\n\n:\\pi = 3 + \\cfrac{1}{6 + \\cfrac{9}{6 + \\cfrac{25}{6 + \\ddots}}}\n\n\n;See also:\n:*   [[Continued fraction/Arithmetic]] for tasks that do arithmetic over continued fractions.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace ContinuedFraction {\n    class Program {\n        static double Calc(Func<int, int[]> f, int n) {\n            double temp = 0.0;\n            for (int ni = n; ni >= 1; ni--) {\n                int[] p = f(ni);\n                temp = p[1] / (p[0] + temp);\n            }\n            return f(0)[0] + temp;\n        }\n\n        static void Main(string[] args) {\n            List<Func<int, int[]>> fList = new List<Func<int, int[]>>();\n            fList.Add(n => new int[] { n > 0 ? 2 : 1, 1 });\n            fList.Add(n => new int[] { n > 0 ? n : 2, n > 1 ? (n - 1) : 1 });\n            fList.Add(n => new int[] { n > 0 ? 6 : 3, (int) Math.Pow(2 * n - 1, 2) });\n\n            foreach (var f in fList) {\n                Console.WriteLine(Calc(f, 200));\n            }\n        }\n    }\n}"}
{"title": "Continued fraction/Arithmetic/Construct from rational number", "language": "C sharp|C#", "task": "To understand this task in context please see [[Continued fraction arithmetic]]\nThe purpose of this task is to write a function \\mathit{r2cf}(\\mathrm{int} N_1, \\mathrm{int} N_2), or \\mathit{r2cf}(\\mathrm{Fraction} N), which will output a continued fraction assuming:\n:N_1 is the numerator\n:N_2 is the denominator\n  \nThe function should output its results one digit at a time each time it is called, in a manner sometimes described as lazy evaluation.\n\nTo achieve this it must determine: the integer part; and remainder part, of N_1 divided by N_2. It then sets N_1 to N_2 and N_2 to the determined remainder part. It then outputs the determined integer part. It does this until \\mathrm{abs}(N_2) is zero.\n\nDemonstrate the function by outputing the continued fraction for:\n: 1/2\n: 3\n: 23/8\n: 13/11\n: 22/7\n: -151/77\n\\sqrt 2 should approach [1; 2, 2, 2, 2, \\ldots] try ever closer rational approximations until boredom gets the better of you:\n: 14142,10000\n: 141421,100000\n: 1414214,1000000\n: 14142136,10000000\n\nTry :\n: 31,10\n: 314,100\n: 3142,1000\n: 31428,10000\n: 314285,100000\n: 3142857,1000000\n: 31428571,10000000\n: 314285714,100000000\n\nObserve how this rational number behaves differently to \\sqrt 2 and convince yourself that, in the same way as 3.7 may be represented as 3.70 when an extra decimal place is required, [3;7] may be represented as [3;7,\\infty] when an extra term is required.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nclass Program\n{\n    static IEnumerable<int> r2cf(int n1, int n2)\n    {\n        while (Math.Abs(n2) > 0)\n        {\n            int t1 = n1 / n2;\n            int t2 = n2;\n            n2 = n1 - t1 * n2;\n            n1 = t2;\n            yield return t1;\n        }\n    }\n\n    static void spit(IEnumerable<int> f)\n    {\n        foreach (int n in f) Console.Write(\" {0}\", n);\n        Console.WriteLine();\n    }\n\n    static void Main(string[] args)\n    {\n        spit(r2cf(1, 2));\n        spit(r2cf(3, 1));\n        spit(r2cf(23, 8));\n        spit(r2cf(13, 11));\n        spit(r2cf(22, 7));\n        spit(r2cf(-151, 77));\n        for (int scale = 10; scale <= 10000000; scale *= 10)\n        {\n            spit(r2cf((int)(Math.Sqrt(2) * scale), scale));\n        }\n        spit(r2cf(31, 10));\n        spit(r2cf(314, 100)); \n        spit(r2cf(3142, 1000));\n        spit(r2cf(31428, 10000));\n        spit(r2cf(314285, 100000));\n        spit(r2cf(3142857, 1000000));\n        spit(r2cf(31428571, 10000000));\n        spit(r2cf(314285714, 100000000));\n    }\n}\n"}
{"title": "Convert decimal number to rational", "language": "C sharp|C# from C", "task": "The task is to write a program to transform a decimal number into a fraction in lowest terms.\n\nIt is not always possible to do this exactly. For instance, while rational numbers can be converted to decimal representation, some of them need an infinite number of digits to be represented exactly in decimal form. Namely, repeating decimals such as 1/3 = 0.333...\n\nBecause of this, the following fractions cannot be obtained (reliably) unless the language has some way of representing repeating decimals:\n* 67 / 74 = 0.9(054) = 0.9054054...\n* 14 / 27 = 0.(518)  = 0.518518...\n\nAcceptable output:\n\n* 0.9054054 - 4527027 / 5000000\n* 0.518518  - 259259 / 500000\n\nFinite decimals are of course no problem:\n\n* 0.75      - 3 / 4 \n\n", "solution": "using System;\nusing System.Text;\n\nnamespace RosettaDecimalToFraction\n{\n    public class Fraction\n    {\n        public Int64 Numerator;\n        public Int64 Denominator;\n        public Fraction(double f, Int64 MaximumDenominator = 4096)\n        {\n            /* Translated from the C version. */\n            /*  a: continued fraction coefficients. */\n            Int64 a;\n            var h = new Int64[3] { 0, 1, 0 };\n            var k = new Int64[3] { 1, 0, 0 };\n            Int64 x, d, n = 1;\n            int i, neg = 0;\n\n            if (MaximumDenominator <= 1)\n            {\n                Denominator = 1;\n                Numerator = (Int64)f;\n                return;\n            }\n\n            if (f < 0) { neg = 1; f = -f; }\n\n            while (f != Math.Floor(f)) { n <<= 1; f *= 2; }\n            d = (Int64)f;\n\n            /* continued fraction and check denominator each step */\n            for (i = 0; i < 64; i++)\n            {\n                a = (n != 0) ? d / n : 0;\n                if ((i != 0) && (a == 0)) break;\n\n                x = d; d = n; n = x % n;\n\n                x = a;\n                if (k[1] * a + k[0] >= MaximumDenominator)\n                {\n                    x = (MaximumDenominator - k[0]) / k[1];\n                    if (x * 2 >= a || k[1] >= MaximumDenominator)\n                        i = 65;\n                    else\n                        break;\n                }\n\n                h[2] = x * h[1] + h[0]; h[0] = h[1]; h[1] = h[2];\n                k[2] = x * k[1] + k[0]; k[0] = k[1]; k[1] = k[2];\n            }\n            Denominator = k[1];\n            Numerator = neg != 0 ? -h[1] : h[1];\n        }\n        public override string ToString()\n        {\n            return string.Format(\"{0} / {1}\", Numerator, Denominator);\n        }\n    }\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            Console.OutputEncoding = UTF8Encoding.UTF8;\n            foreach (double d in new double[] { 0.9054054, 0.518518, 0.75, 0.4285714, 0.833333,\n                0.90909, 3.14159265358979, 2.7182818284590451 })\n            {\n                var f = new Fraction(d, d >= 2 ? 65536 : 4096);\n                Console.WriteLine(\"{0,20} \u2192 {1}\", d, f);\n\n            }\n        }\n    }\n}\n"}
{"title": "Convert seconds to compound duration", "language": "C sharp|C#", "task": "Write a function or program which:\n*   takes a positive integer representing a duration in seconds as input (e.g., 100), and\n*   returns a string which shows the same duration decomposed into:\n:::*   weeks,\n:::*   days, \n:::*   hours, \n:::*   minutes,   and \n:::*   seconds.\n\nThis is detailed below (e.g., \"2 hr, 59 sec\").\n\n\nDemonstrate that it passes the following three test-cases:\n\n'''''Test Cases'''''\n\n:::::{| class=\"wikitable\"\n|-\n! input number\n! output string\n|-\n| 7259\n| 2 hr, 59 sec\n|-\n| 86400\n| 1 d\n|-\n| 6000000\n| 9 wk, 6 d, 10 hr, 40 min\n|}\n\n'''''Details'''''\n\nThe following five units should be used:\n:::::{| class=\"wikitable\"\n|-\n! unit\n! suffix used in output\n! conversion\n|-\n| week\n| wk\n| 1 week = 7 days\n|-\n| day\n| d\n| 1 day = 24 hours\n|-\n| hour\n| hr\n| 1 hour = 60 minutes\n|-\n| minute\n| min\n| 1 minute = 60 seconds\n|-\n| second\n| sec\n| \n|}\n\nHowever, '''only''' include quantities with non-zero values in the output (e.g., return \"1 d\" and not \"0 wk, 1 d, 0 hr, 0 min, 0 sec\").\n\nGive larger units precedence over smaller ones as much as possible (e.g., return 2 min, 10 sec and not 1 min, 70 sec or 130 sec)\n\nMimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace ConvertSecondsToCompoundDuration\n{\n  class Program\n  {\n    static void Main( string[] args )\n    {\n      foreach ( string arg in args )\n      {\n        int duration ;\n        bool isValid = int.TryParse( arg , out duration ) ;\n\n        if ( !isValid     ) { Console.Error.WriteLine( \"ERROR: Not an integer: {0}\"           , arg ) ; }\n        if ( duration < 0 ) { Console.Error.WriteLine( \"ERROR: duration must be non-negative\" , arg ) ; }\n        \n        Console.WriteLine();\n        Console.WriteLine( \"{0:#,##0} seconds ==> {1}\" , duration , FormatAsDuration(duration) ) ;\n        \n      }\n    }\n    \n    private static string FormatAsDuration( int duration )\n    {\n      if ( duration < 0 ) throw new ArgumentOutOfRangeException(\"duration\") ;\n      return string.Join( \", \" , GetDurationParts(duration)  ) ;\n    }\n    \n    private static IEnumerable<string> GetDurationParts( int duration )\n    {\n      var parts = new[]\n      {\n        new { Name=\"wk\" , Length = 7*24*60*60*1 , } ,\n        new { Name=\"d\"  , Length =   24*60*60*1 , } ,\n        new { Name=\"h\"  , Length =      60*60*1 , } ,\n        new { Name=\"m\"  , Length =         60*1 , } ,\n        new { Name=\"s\"  , Length =            1 , } ,\n      } ;\n      \n      foreach ( var part in parts )\n      {\n        int n = Math.DivRem( duration , part.Length , out duration ) ;\n        if ( n > 0 ) yield return string.Format( \"{0} {1}\" , n , part.Name ) ;\n      }\n      \n    }\n    \n  }\n  \n}"}
{"title": "Convert seconds to compound duration", "language": "C sharp 6", "task": "Write a function or program which:\n*   takes a positive integer representing a duration in seconds as input (e.g., 100), and\n*   returns a string which shows the same duration decomposed into:\n:::*   weeks,\n:::*   days, \n:::*   hours, \n:::*   minutes,   and \n:::*   seconds.\n\nThis is detailed below (e.g., \"2 hr, 59 sec\").\n\n\nDemonstrate that it passes the following three test-cases:\n\n'''''Test Cases'''''\n\n:::::{| class=\"wikitable\"\n|-\n! input number\n! output string\n|-\n| 7259\n| 2 hr, 59 sec\n|-\n| 86400\n| 1 d\n|-\n| 6000000\n| 9 wk, 6 d, 10 hr, 40 min\n|}\n\n'''''Details'''''\n\nThe following five units should be used:\n:::::{| class=\"wikitable\"\n|-\n! unit\n! suffix used in output\n! conversion\n|-\n| week\n| wk\n| 1 week = 7 days\n|-\n| day\n| d\n| 1 day = 24 hours\n|-\n| hour\n| hr\n| 1 hour = 60 minutes\n|-\n| minute\n| min\n| 1 minute = 60 seconds\n|-\n| second\n| sec\n| \n|}\n\nHowever, '''only''' include quantities with non-zero values in the output (e.g., return \"1 d\" and not \"0 wk, 1 d, 0 hr, 0 min, 0 sec\").\n\nGive larger units precedence over smaller ones as much as possible (e.g., return 2 min, 10 sec and not 1 min, 70 sec or 130 sec)\n\nMimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).\n\n\n", "solution": "private static string ConvertToCompoundDuration(int seconds)\n{\n    if (seconds < 0) throw new ArgumentOutOfRangeException(nameof(seconds));\n    if (seconds == 0) return \"0 sec\";\n\n    TimeSpan span = TimeSpan.FromSeconds(seconds);\n    int[] parts = {span.Days / 7, span.Days % 7, span.Hours, span.Minutes, span.Seconds};\n    string[] units = {\" wk\", \" d\", \" hr\", \" min\", \" sec\"};\n\n    return string.Join(\", \",\n        from index in Enumerable.Range(0, units.Length)\n        where parts[index] > 0\n        select parts[index] + units[index]);\n}"}
{"title": "Copy stdin to stdout", "language": ".NET Framework 4.0 or later", "task": "Create an executable file that copies stdin to stdout, or else a script that does so through the invocation of an interpreter at the command line.\n\n", "solution": "using System;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        Console.OpenStandardInput().CopyTo(Console.OpenStandardOutput());\n    }\n}\n"}
{"title": "Count the coins", "language": "C sharp|C#", "task": "There are four types of common coins in   US   currency: \n:::#   quarters   (25 cents)\n:::#   dimes   (10 cents)\n:::#   nickels   (5 cents),   and \n:::#   pennies   (1 cent)  \n\n\nThere are six ways to make change for 15 cents:\n:::#   A dime and a nickel \n:::#   A dime and 5 pennies\n:::#   3 nickels\n:::#   2 nickels and 5 pennies\n:::#   A nickel and 10 pennies\n:::#   15 pennies\n\n\n;Task:\nHow many ways are there to make change for a dollar using these common coins?     (1 dollar = 100 cents).\n\n\n;Optional:\nLess common are dollar coins (100 cents);   and very rare are half dollars (50 cents).   With the addition of these two coins, how many ways are there to make change for $1000? \n\n(Note:   the answer is larger than   232).\n\n\n;References:\n* an algorithm from the book ''Structure and Interpretation of Computer Programs''.\n* an article in the algorithmist.\n* Change-making problem on Wikipedia.\n\n", "solution": "// Adapted from http://www.geeksforgeeks.org/dynamic-programming-set-7-coin-change/\n    class Program\n    {\n        static long Count(int[] C, int m, int n)\n        {\n            var table = new long[n + 1];\n            table[0] = 1;\n            for (int i = 0; i < m; i++)\n                for (int j = C[i]; j <= n; j++)\n                    table[j] += table[j - C[i]];\n            return table[n];\n        }\n        static void Main(string[] args)\n        {\n            var C = new int[] { 1, 5, 10, 25 };\n            int m = C.Length;\n            int n = 100;\n            Console.WriteLine(Count(C, m, n));  //242\n            Console.ReadLine();\n        }\n    }\n"}
{"title": "Create an HTML table", "language": "C sharp|C#", "task": "Create an HTML table. \n* The table body should have at least three rows of three columns.\n* Each of these three columns should be labelled \"X\", \"Y\", and \"Z\". \n* An extra column should be added at either the extreme left or the extreme right of the table that has no heading, but is filled with sequential row numbers. \n* The rows of the \"X\", \"Y\", and \"Z\" columns should be filled with random or sequential integers having 4 digits or less. \n* The numbers should be aligned in the same fashion for all columns.\n\n", "solution": "using System;\nusing System.Text;\nusing System.Xml;\n\nnamespace N\n{\n\tpublic class T\n\t{\n\t\tpublic static void Main()\n\t\t{\n\t\t\tvar headers = new [] { \"\", \"X\", \"Y\", \"Z\" };\n\t\t\t\n\t\t\tvar cols = headers.Select(name =>\n\t\t\t\tnew XElement(\n\t\t\t\t\t\"th\",\n\t\t\t\t\tname,\n\t\t\t\t\tnew XAttribute(\"text-align\", \"center\")\n\t\t\t\t)\n\t\t\t);\n\t\t\n\t\t\tvar rows = Enumerable.Range(0, 4).Select(ri =>\n\t\t\t\tnew XElement(\n\t\t\t\t\t\"tr\",\n\t\t\t\t\tnew XElement(\"td\", ri),\n\t\t\t\t\tEnumerable.Range(0, 4).Select(ci =>\n\t\t\t\t\t\tnew XElement(\n\t\t\t\t\t\t\t\"td\",\n\t\t\t\t\t\t\tci,\n\t\t\t\t\t\t\tnew XAttribute(\"text-align\", \"center\")\n\t\t\t\t\t\t)\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\t);\n\t\t\t\t\n\t\t\tvar xml = new XElement(\n\t\t\t\t\"table\", \n\t\t\t\tnew XElement(\n\t\t\t\t\t\"thead\", \n\t\t\t\t\tnew XElement(\"tr\",    cols),\n\t\t\t\t\tnew XElement(\"tbody\", rows)\n\t\t\t\t)\n\t\t\t);\n\t\t\t\n\t\t\tConsole.WriteLine(xml.ToString());\n\t\t}\n\t}\n}\n"}
{"title": "Currency", "language": "C sharp|C#", "task": "Show how to represent currency in a simple example, using a data type that represent exact values of dollars and cents.  \n\n\n;Note:\nThe '''IEEE 754''' binary floating point representations of numbers like   '''2.86'''   and   '''.0765'''   are not exact.\n\nFor this example, data will be two items with prices in dollars and cents, a quantity for each, and a tax rate. \n \nUse the values:\n::* 4000000000000000 hamburgers at $5.50 each       (four quadrillion burgers)\n::* 2 milkshakes at $2.86 each, and \n::* a tax rate of 7.65%.  \n\n\n(That number of hamburgers is a 4 with 15 zeros after it.    The number is contrived to exclude naive task solutions using 64 bit floating point types.)  \n\nCompute and output (show results on this page):\n::* the total price before tax\n::* the tax\n::* the total with tax  \n\n\nThe tax value must be computed by rounding to the nearest whole cent and this exact value must be added to the total price before tax.  \n\nThe output must show dollars and cents with a decimal point. \n \nThe three results displayed should be:\n::* 22000000000000005.72\n::* 1683000000000000.44 \n::* 23683000000000006.16  \n\n\nDollar signs and thousands separators are optional.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace Currency\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            MenuItem hamburger = new MenuItem() { Name = \"Hamburger\", Price = 5.5M };\n            MenuItem milkshake = new MenuItem() { Name = \"Milkshake\", Price = 2.86M };\n\n            IList<CartItem> cart = new List<CartItem>();\n            cart.Add(new CartItem() { item = hamburger, quantity = 4000000000000000 });\n            cart.Add(new CartItem() { item = milkshake, quantity = 2 });\n\n            decimal total = CalculateTotal(cart);\n\n            Console.WriteLine(string.Format(\"Total before tax: {0:C}\", total));\n\n            // Add Tax\n            decimal tax = total * 0.0765M;\n\n            Console.WriteLine(string.Format(\"Tax: {0:C}\", tax));\n\n            total += tax;\n\n            Console.WriteLine(string.Format(\"Total with tax: {0:C}\", total));\n        }\n\n        private static decimal CalculateTotal(IList<CartItem> cart)\n        {\n            decimal total = 0M;\n\n            foreach (CartItem item in cart)\n            {\n                total += item.quantity * item.item.Price;\n            }\n\n            return total;\n        }\n\n        private struct MenuItem\n        {\n            public string Name { get; set; }\n            public decimal Price { get; set; }\n        }\n\n        private struct CartItem\n        {\n            public MenuItem item { get; set; }\n            public decimal quantity { get; set; }\n        }\n    }\n}"}
{"title": "Currying", "language": "C sharp|C#", "task": "{{Wikipedia|Currying}}\n\n\n;Task:\nCreate a simple demonstrative example of Currying in a specific language.  \n\nAdd any historic details as to how the feature made its way into the language.\n\n\n\n", "solution": "public delegate int Plus(int y); \npublic delegate Plus CurriedPlus(int x);\npublic static CurriedPlus plus = \n      delegate(int x) {return delegate(int y) {return x + y;};};\nstatic void Main()\n{\n    int sum = plus(3)(4); // sum = 7\n    int sum2= plus(2)(plus(3)(4)) // sum2 = 9\n}"}
{"title": "Cyclotomic polynomial", "language": "C sharp 8", "task": "The nth Cyclotomic polynomial, for any positive integer n, is the unique irreducible polynomial of largest degree with integer coefficients that is a divisor of x^n - 1, and is not a divisor of x^k - 1 for any k < n.\n\n\n;Task:\n*   Find and print the first 30 cyclotomic polynomials.\n*   Find and print the order of the first 10 cyclotomic polynomials that have n or -n as a coefficient.\n\n\n;See also\n*   Wikipedia article, Cyclotomic polynomial, showing ways to calculate them.\n*   The sequence A013594 with the smallest order of cyclotomic polynomial containing n or -n as a coefficient.\n\n", "solution": "using System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing System.Linq;\nusing IntMap = System.Collections.Generic.Dictionary<int, int>;\n\npublic static class CyclotomicPolynomial\n{\n    public static void Main2() {\n        Console.WriteLine(\"Task 1: Cyclotomic polynomials for n <= 30:\");\n        for (int i = 1; i <= 30; i++) {\n            var p = GetCyclotomicPolynomial(i);\n            Console.WriteLine($\"CP[{i}] = {p.ToString()}\");\n        }\n        Console.WriteLine();\n\n        Console.WriteLine(\"Task 2: Smallest cyclotomic polynomial with n or -n as a coefficient:\");\n        for (int i = 1, n = 0; i <= 10; i++) {\n            while (true) {\n                n++;\n                var p = GetCyclotomicPolynomial(n);\n                if (p.Any(t => Math.Abs(t.Coefficient) == i)) {\n                    Console.WriteLine($\"CP[{n}] has coefficient with magnitude = {i}\");\n                    n--;\n                    break;\n                }\n            }\n        }\n    }\n\n    private const int MaxFactors = 100_000;\n    private const int Algorithm = 2;\n    private static readonly Term x = new Term(1, 1);\n    private static readonly Dictionary<int, Polynomial> polyCache =\n        new Dictionary<int, Polynomial> { [1] = x - 1 };\n    private static readonly Dictionary<int, IntMap> factorCache =\n        new Dictionary<int, IntMap> { [2] = new IntMap { [2] = 1 } };\n\n    private static Polynomial GetCyclotomicPolynomial(in int n) {\n        if (polyCache.TryGetValue(n, out var result)) return result;\n\n        var factors = GetFactors(n);\n        if (factors.ContainsKey(n)) { //n is prime\n            result = new Polynomial(from exp in ..n select x[exp]);\n        } else if (factors.Count == 2 && factors.Contains(2, 1) && factors.Contains(n/2, 1)) { //n = 2p\n            result = new Polynomial(from i in ..(n/2) select (IsOdd(i) ? -x : x)[i]);\n        } else if (factors.Count == 1 && factors.TryGetValue(2, out int h)) { //n = 2^h\n            result = x[1<<(h-1)] + 1;\n        } else if (factors.Count == 1 && !factors.ContainsKey(n)) { // n = p^k\n            (int p, int k) = factors.First();\n            result = new Polynomial(from i in ..p select x[i * (int)Math.Pow(p, k-1)]);\n        } else if (factors.Count == 2 && factors.ContainsKey(2)) { //n = 2^h * p^k\n            (int p, int k) = factors.First(entry => entry.Key != 2);\n            int twoExp = 1 << (factors[2] - 1);\n            result = new Polynomial(from i in ..p select (IsOdd(i) ? -x : x)[i * twoExp * (int)Math.Pow(p, k-1)]);\n        } else if (factors.ContainsKey(2) && IsOdd(n/2) && n/2 > 1) { // CP(2m)[x] = CP[-m][x], n is odd > 1\n            Polynomial cycloDiv2 = GetCyclotomicPolynomial(n/2);\n            result = new Polynomial(from term in cycloDiv2 select IsOdd(term.Exponent) ? -term : term);\n            #pragma warning disable CS0162\n        } else if (Algorithm == 0) {\n            var divisors = GetDivisors(n);\n            result = x[n] - 1;\n            foreach (int d in divisors) result /= GetCyclotomicPolynomial(d);\n        } else if (Algorithm == 1) {\n            var divisors = GetDivisors(n).ToList();\n            int maxDivisor = divisors.Max();\n            result = (x[n] - 1) / (x[maxDivisor] - 1);\n            foreach (int d in divisors.Where(div => maxDivisor % div == 0)) {\n                result /= GetCyclotomicPolynomial(d);\n            }\n        } else if (Algorithm == 2) {\n            int m = 1;\n            result = GetCyclotomicPolynomial(m);\n            var primes = factors.Keys.ToList();\n            primes.Sort();\n            foreach (int prime in primes) {\n                var cycloM = result;\n                result = new Polynomial(from term in cycloM select term.Coefficient * x[term.Exponent * prime]);\n                result /= cycloM;\n                m *= prime;\n            }\n            int s = n / m;\n            result = new Polynomial(from term in result select term.Coefficient * x[term.Exponent * s]);\n            #pragma warning restore CS0162\n        } else {\n            throw new InvalidOperationException(\"Invalid algorithm\");\n        }\n        polyCache[n] = result;\n        return result;\n    }\n\n    private static bool IsOdd(int i) => (i & 1) != 0;\n    private static bool Contains(this IntMap map, int key, int value) => map.TryGetValue(key, out int v) && v == value;\n    private static int GetOrZero(this IntMap map, int key) => map.TryGetValue(key, out int v) ? v : 0;\n    private static IEnumerable<T> Select<T>(this Range r, Func<int, T> f) => Enumerable.Range(r.Start.Value, r.End.Value - r.Start.Value).Select(f);\n\n    private static IntMap GetFactors(in int n) {\n        if (factorCache.TryGetValue(n, out var factors)) return factors;\n\n        factors = new IntMap();\n        if (!IsOdd(n)) {\n            foreach (var entry in GetFactors(n/2)) factors.Add(entry.Key, entry.Value);\n            factors[2] = factors.GetOrZero(2) + 1;\n            return Cache(n, factors);\n        }\n        for (int i = 3; i * i <= n; i+=2) {\n            if (n % i == 0) {\n                foreach (var entry in GetFactors(n/i)) factors.Add(entry.Key, entry.Value);\n                factors[i] = factors.GetOrZero(i) + 1;\n                return Cache(n, factors);\n            }\n        }\n        factors[n] = 1;\n        return Cache(n, factors);\n    }\n\n    private static IntMap Cache(int n, IntMap factors) {\n        if (n < MaxFactors) factorCache[n] = factors;\n        return factors;\n    }\n\n    private static IEnumerable<int> GetDivisors(int n) {\n        for (int i = 1; i * i <= n; i++) {\n            if (n % i == 0) {\n                yield return i;\n                int div = n / i;\n                if (div != i && div != n) yield return div;\n            }\n        }\n    }\n\n    public sealed class Polynomial : IEnumerable<Term>\n    {\n        public Polynomial() { }\n        public Polynomial(params Term[] terms) : this(terms.AsEnumerable()) { }\n\n        public Polynomial(IEnumerable<Term> terms) {\n            Terms.AddRange(terms);\n            Simplify();\n        }\n\n        private List<Term>? terms;\n        private List<Term> Terms => terms ??= new List<Term>();\n\n        public int Count => terms?.Count ?? 0;\n        public int Degree => Count == 0 ? -1 : Terms[0].Exponent;\n        public int LeadingCoefficient => Count == 0 ? 0 : Terms[0].Coefficient;\n\n        public IEnumerator<Term> GetEnumerator() => Terms.GetEnumerator();\n        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();\n\n        public override string ToString() => Count == 0 ? \"0\" : string.Join(\" + \", Terms).Replace(\"+ -\", \"- \");\n\n        public static Polynomial operator *(Polynomial p, Term t) => new Polynomial(from s in p select s * t);\n        public static Polynomial operator +(Polynomial p, Polynomial q) => new Polynomial(p.Terms.Concat(q.Terms));\n        public static Polynomial operator -(Polynomial p, Polynomial q) => new Polynomial(p.Terms.Concat(q.Terms.Select(t => -t)));\n        public static Polynomial operator *(Polynomial p, Polynomial q) => new Polynomial(from s in p from t in q select s * t);\n        public static Polynomial operator /(Polynomial p, Polynomial q) => p.Divide(q).quotient;\n\n        public (Polynomial quotient, Polynomial remainder) Divide(Polynomial divisor) {\n            if (Degree < 0) return (new Polynomial(), this);\n            Polynomial quotient = new Polynomial();\n            Polynomial remainder = this;\n            int lcv = divisor.LeadingCoefficient;\n            int dv = divisor.Degree;\n            while (remainder.Degree >= divisor.Degree) {\n                int lcr = remainder.LeadingCoefficient;\n                Term div = new Term(lcr / lcv, remainder.Degree - dv);\n                quotient.Terms.Add(div);\n                remainder += divisor * -div;\n            }\n            quotient.Simplify();\n            remainder.Simplify();\n            return (quotient, remainder);\n        }\n\n        private void Simplify() {\n            if (Count < 2) return;\n            Terms.Sort((a, b) => -a.CompareTo(b));\n            for (int i = Terms.Count - 1; i > 0; i--) {\n                Term s = Terms[i-1];\n                Term t = Terms[i];\n                if (t.Exponent == s.Exponent) {\n                    Terms[i-1] = new Term(s.Coefficient + t.Coefficient, s.Exponent);\n                    Terms.RemoveAt(i);\n                }\n            }\n            Terms.RemoveAll(t => t.IsZero);\n        }\n\n    }\n    \n    public readonly struct Term : IEquatable<Term>, IComparable<Term>\n    {\n        public Term(int coefficient, int exponent = 0) => (Coefficient, Exponent) = (coefficient, exponent);\n\n        public Term this[int exponent] => new Term(Coefficient, exponent); //Using x[exp] because x^exp has low precedence\n        public int Coefficient { get; }\n        public int Exponent { get; }\n        public bool IsZero => Coefficient == 0;\n\n        public static Polynomial operator +(Term left, Term right) => new Polynomial(left, right);\n        public static Polynomial operator -(Term left, Term right) => new Polynomial(left, -right);\n        public static implicit operator Term(int coefficient) => new Term(coefficient);\n        public static Term operator -(Term t) => new Term(-t.Coefficient, t.Exponent);\n        public static Term operator *(Term left, Term right) => new Term(left.Coefficient * right.Coefficient, left.Exponent + right.Exponent);\n\n        public static bool operator ==(Term left, Term right) => left.Equals(right);\n        public static bool operator !=(Term left, Term right) => !left.Equals(right);\n        public static bool operator  <(Term left, Term right) => left.CompareTo(right)  < 0;\n        public static bool operator  >(Term left, Term right) => left.CompareTo(right)  > 0;\n        public static bool operator <=(Term left, Term right) => left.CompareTo(right) <= 0;\n        public static bool operator >=(Term left, Term right) => left.CompareTo(right) >= 0;\n\n        public bool Equals(Term other) => Exponent == other.Exponent && Coefficient == other.Coefficient;\n        public override bool Equals(object? obj) => obj is Term t && Equals(t);\n        public override int GetHashCode() => Coefficient.GetHashCode() * 31 + Exponent.GetHashCode();\n\n        public int CompareTo(Term other) {\n            int c = Exponent.CompareTo(other.Exponent);\n            if (c != 0) return c;\n            return Coefficient.CompareTo(other.Coefficient);\n        }\n\n        public override string ToString() => (Coefficient, Exponent) switch {\n            (0,  _) => \"0\",\n            (_,  0) => $\"{Coefficient}\",\n            (1,  1) => \"x\",\n            (-1, 1) => \"-x\",\n            (_,  1) => $\"{Coefficient}x\",\n            (1,  _) => $\"x^{Exponent}\",\n            (-1, _) => $\"-x^{Exponent}\",\n                    _ => $\"{Coefficient}x^{Exponent}\"\n        };\n    }\n}"}
{"title": "Damm algorithm", "language": "C sharp|C# from Java", "task": "The '''Damm''' algorithm is a checksum algorithm which detects all single digit errors and adjacent transposition errors. \n\n\nThe algorithm is named after H. Michael Damm.\n\n\n;Task:\nVerify the checksum, stored as last digit of an input.\n\n\n\n", "solution": "using System;\n\nnamespace DammAlgorithm {\n    class Program {\n        static int[,] table = {\n            {0, 3, 1, 7, 5, 9, 8, 6, 4, 2},\n            {7, 0, 9, 2, 1, 5, 4, 8, 6, 3},\n            {4, 2, 0, 6, 8, 7, 1, 3, 5, 9},\n            {1, 7, 5, 0, 9, 8, 3, 4, 2, 6},\n            {6, 1, 2, 3, 0, 4, 5, 9, 7, 8},\n            {3, 6, 7, 4, 2, 0, 9, 5, 8, 1},\n            {5, 8, 6, 9, 7, 2, 0, 1, 3, 4},\n            {8, 9, 4, 5, 3, 6, 2, 0, 1, 7},\n            {9, 4, 3, 8, 6, 1, 7, 2, 0, 5},\n            {2, 5, 8, 1, 4, 3, 6, 7, 9, 0},\n        };\n\n        static bool Damm(string s) {\n            int interim = 0;\n            foreach (char c in s) {\n                interim = table[interim, c - '0'];\n            }\n            return interim == 0;\n        }\n\n        static void Main(string[] args) {\n            int[] numbers = { 5724, 5727, 112946, 112949 };\n            foreach (int number in numbers) {\n                bool isValid = Damm(number.ToString());\n                if (isValid) {\n                    Console.WriteLine(\"{0,6} is valid\", number);\n                }\n                else {\n                    Console.WriteLine(\"{0,6} is invalid\", number);\n                }\n            }\n        }\n    }\n}"}
{"title": "De Bruijn sequences", "language": "C sharp|C# from Kotlin", "task": "{{DISPLAYTITLE:de Bruijn sequences}}\nThe sequences are named after the Dutch mathematician   Nicolaas Govert de Bruijn.\n\n\nA note on Dutch capitalization:   Nicolaas' last name is   '''de Bruijn''',   the   '''de'''   isn't normally capitalized\nunless it's the first word in a sentence.   Rosetta Code (more or less by default or by fiat) requires the first word in the task name to be\ncapitalized.\n\n\nIn combinatorial mathematics,   a   '''de Bruijn sequence'''   of order    ''n''    on\na    size-''k''    alphabet (computer science)    ''A''    is a cyclic sequence in which every\npossible    length-''n''    string (computer science, formal theory)   on    ''A''    occurs\nexactly once as a contiguous substring.\n\n\nSuch a sequence is denoted by    ''B''(''k'', ''n'')    and has\nlength   ''k''''n'',   which is also the number of distinct substrings of\nlength   ''n''   on   ''A'';    \nde Bruijn sequences are therefore optimally short.\n\n\nThere are:\n                          (k!)k(n-1)   /   kn\ndistinct de Bruijn sequences    ''B''(''k'', ''n''). \n\n\n;Task:\nFor this Rosetta Code task,   a   '''de Bruijn'''   sequence is to be generated that can be used to shorten a brute-force attack on\na   PIN-like   code lock that does not have an \"enter\"\nkey and accepts the last    ''n''    digits entered.\n\n\nNote:   automated teller machines (ATMs)   used to work like\nthis,   but their software has been updated to not allow a brute-force attack.\n\n\n;Example:\nA   digital door lock   with a 4-digit code would\nhave ''B'' (10, 4) solutions,   with a length of   '''10,000'''   (digits).\n\nTherefore, only at most     '''10,000 + 3'''     (as the solutions are cyclic or ''wrap-around'')   presses are needed to\nopen the lock.\n\nTrying all 4-digit codes separately would require   '''4 x 10,000'''   or   '''40,000'''   presses.\n\n\n;Task requirements:\n:*   Generate a de Bruijn sequence for a 4-digit (decimal) PIN code.\n:::*   Show the length of the generated de Bruijn sequence.\n:::*   (There are many possible de Bruijn sequences that solve this task,   one solution is shown on the ''discussion'' page).\n:::*   Show the first and last   '''130'''   digits of the de Bruijn sequence.\n:*   Verify that all four-digit (decimal)   '''1,000'''   PIN codes are contained within the de Bruijn sequence.\n:::*   0000, 0001, 0002, 0003,   ...   9996, 9997, 9998, 9999   (note the leading zeros).\n:*   Reverse the de Bruijn sequence.\n:*   Again, perform the (above) verification test.\n:*   Replace the 4,444th digit with a period (.) in the original de Bruijn sequence.\n:::*   Perform the verification test (again).   There should be four PIN codes missing.\n\n\n(The last requirement is to ensure that the verification tests performs correctly.   The verification processes should list\nany and all missing PIN codes.)\n\nShow all output here, on this page.\n\n\n\n;References:\n:*   Wikipedia           entry:   de Bruijn sequence.\n:*   MathWorld           entry:   de Bruijn sequence.\n:*   An  OEIS  entry:   A166315 lexicographically earliest binary de Bruijn sequences, B(2,n)     --- Not B(10,4),   but possibly relevant.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Text;\n\nnamespace DeBruijn {\n    class Program {\n        const string digits = \"0123456789\";\n\n        static string DeBruijn(int k, int n) {\n            var alphabet = digits.Substring(0, k);\n            var a = new byte[k * n];\n            var seq = new List<byte>();\n            void db(int t, int p) {\n                if (t > n) {\n                    if (n % p == 0) {\n                        seq.AddRange(new ArraySegment<byte>(a, 1, p));\n                    }\n                } else {\n                    a[t] = a[t - p];\n                    db(t + 1, p);\n                    var j = a[t - p] + 1;\n                    while (j < k) {\n                        a[t] = (byte)j;\n                        db(t + 1, t);\n                        j++;\n                    }\n                }\n            }\n            db(1, 1);\n            var buf = new StringBuilder();\n            foreach (var i in seq) {\n                buf.Append(alphabet[i]);\n            }\n            var b = buf.ToString();\n            return b + b.Substring(0, n - 1);\n        }\n\n        static bool AllDigits(string s) {\n            foreach (var c in s) {\n                if (c < '0' || '9' < c) {\n                    return false;\n                }\n            }\n            return true;\n        }\n\n        static void Validate(string db) {\n            var le = db.Length;\n            var found = new int[10_000];\n            var errs = new List<string>();\n            // Check all strings of 4 consecutive digits within 'db'\n            // to see if all 10,000 combinations occur without duplication.\n            for (int i = 0; i < le - 3; i++) {\n                var s = db.Substring(i, 4);\n                if (AllDigits(s)) {\n                    int.TryParse(s, out int n);\n                    found[n]++;\n                }\n            }\n            for (int i = 0; i < 10_000; i++) {\n                if (found[i] == 0) {\n                    errs.Add(string.Format(\"    PIN number {0,4} missing\", i));\n                } else if (found[i] > 1) {\n                    errs.Add(string.Format(\"    PIN number {0,4} occurs {1} times\", i, found[i]));\n                }\n            }\n            var lerr = errs.Count;\n            if (lerr == 0) {\n                Console.WriteLine(\"  No errors found\");\n            } else {\n                var pl = lerr == 1 ? \"\" : \"s\";\n                Console.WriteLine(\"  {0} error{1} found:\", lerr, pl);\n                errs.ForEach(Console.WriteLine);\n            }\n        }\n\n        static string Reverse(string s) {\n            char[] arr = s.ToCharArray();\n            Array.Reverse(arr);\n            return new string(arr);\n        }\n\n        static void Main() {\n            var db = DeBruijn(10, 4);\n            var le = db.Length;\n\n            Console.WriteLine(\"The length of the de Bruijn sequence is {0}\", le);\n            Console.WriteLine(\"\\nThe first 130 digits of the de Bruijn sequence are: {0}\", db.Substring(0, 130));\n            Console.WriteLine(\"\\nThe last 130 digits of the de Bruijn sequence are: {0}\", db.Substring(le - 130, 130));\n\n            Console.WriteLine(\"\\nValidating the deBruijn sequence:\");\n            Validate(db);\n\n            Console.WriteLine(\"\\nValidating the reversed deBruijn sequence:\");\n            Validate(Reverse(db));\n\n            var bytes = db.ToCharArray();\n            bytes[4443] = '.';\n            db = new string(bytes);\n            Console.WriteLine(\"\\nValidating the overlaid deBruijn sequence:\");\n            Validate(db);\n        }\n    }\n}"}
{"title": "Deepcopy", "language": "C sharp|C#", "task": "Demonstrate how to copy data structures containing complex heterogeneous and cyclic semantics. \n\nThis is often referred to as deep copying, and is normally required where structures are mutable and to ensure that independent copies can be manipulated without side-effects.\n\nIf this facility is not built into the language, it is permissible to use functions from a common library, or a coded procedure.\n\n\nThe task should show:\n\n* Relevant semantics of structures, such as their homogeneous or heterogeneous properties, or containment of (self- or mutual-reference) cycles.\n\n* Any limitations of the method.\n\n* That the structure and its copy are different.\n\n* Suitable links to external documentation for common libraries.\n\n", "solution": "using System;\n\nnamespace prog\n{\n\tclass MainClass\n\t{\n\t\tclass MyClass : ICloneable\n\t\t{\n\t\t\tpublic MyClass() { f = new int[3]{2,3,5}; c = '1'; }\n\t\t\t\n\t\t\tpublic object Clone()\n\t\t\t{\t\t\t\t\n\t\t\t\tMyClass cpy = (MyClass) this.MemberwiseClone();\n\t\t\t\tcpy.f = (int[]) this.f.Clone();\t\t\t\n\t\t\t\treturn cpy;\n\t\t\t}\n\t\t\t\n\t\t\tpublic char c;\n\t\t\tpublic int[] f;\n\t\t}\n\t\t\n\t\tpublic static void Main( string[] args )\n\t\t{\n\t\t\tMyClass c1 = new MyClass();\n\t\t\tMyClass c2 = (MyClass) c1.Clone();\n\t\t}\n\t}\n}"}
{"title": "Department numbers", "language": "C sharp|C#", "task": "There is a highly organized city that has decided to assign a number to each of their departments:\n::*   police department\n::*   sanitation department\n::*   fire department \n\n\nEach department can have a number between   '''1'''   and   '''7'''   (inclusive).\n\nThe three department numbers are to be unique (different from each other) and must add up to   '''12'''.\n\nThe Chief of the Police doesn't like odd numbers and wants to have an even number for his department.\n\n\n;Task:\nWrite a computer program which outputs all valid combinations.\n\n\nPossible output   (for the 1st and 14th solutions):\n  \n  --police--  --sanitation--  --fire-- \n      2             3            7 \n      6             5            1\n\n", "solution": "using System;\npublic class Program\n{\n    public static void Main() {\n        for (int p = 2; p <= 7; p+=2) {\n            for (int s = 1; s <= 7; s++) {\n                int f = 12 - p - s;\n                if (s >= f) break;\n                if (f > 7) continue;\n                if (s == p || f == p) continue; //not even necessary\n                Console.WriteLine($\"Police:{p}, Sanitation:{s}, Fire:{f}\");\n                Console.WriteLine($\"Police:{p}, Sanitation:{f}, Fire:{s}\");\n            }\n        }\n    }\n}"}
{"title": "Descending primes", "language": "C#|CSharp", "task": "Generate and show all primes with strictly descending decimal digits.\n\n;See also\n;* OEIS:A052014 - Primes with distinct digits in descending order\n\n;Related:\n*[[Ascending primes]]\n\n\n", "solution": "using System;\n\nclass Program {\n\n  static bool ispr(uint n) {\n    if ((n & 1) == 0 || n < 2) return n == 2;\n    for (uint j = 3; j * j <= n; j += 2)\n      if (n % j == 0) return false; return true; }\n\n  static void Main(string[] args) {\n    uint c = 0; int nc;\n    var ps = new uint[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };\n    var nxt = new uint[128];\n    while (true) {\n      nc = 0;\n      foreach (var a in ps) {\n        if (ispr(a))\n          Console.Write(\"{0,8}{1}\", a, ++c % 5 == 0 ? \"\\n\" : \" \");\n        for (uint b = a * 10, l = a % 10 + b++; b < l; b++)\n          nxt[nc++] = b;\n      }\n      if (nc > 1) {\n        Array.Resize (ref ps, nc); Array.Copy(nxt, ps, nc); }\n      else break;\n    }\n    Console.WriteLine(\"\\n{0} descending primes found\", c);\n  }\n}"}
{"title": "Determine if a string has all the same characters", "language": "C sharp|C# from D", "task": "Given a character string   (which may be empty, or have a length of zero characters):\n::*   create a function/procedure/routine to:\n::::*    determine if all the characters in the string are the same\n::::*    indicate if or which character is different from the previous character\n::*   display each string and its length   (as the strings are being examined)\n::*   a zero-length (empty) string shall be considered as all the same character(s)\n::*   process the strings from left-to-right\n::*   if       all the same character,   display a message saying such\n::*   if                  not all the same character,   then:\n::::*    display a message saying such\n::::*    display what character is different\n::::*    only the 1st different character need be displayed\n::::*    display where the different character is in the string\n::::*    the above messages can be part of a single message\n::::*    display the hexadecimal value of the different character\n\n\nUse (at least) these seven test values   (strings):\n:::*   a string of length   0   (an empty string)\n:::*   a string of length   3   which contains three blanks\n:::*   a string of length   1   which contains:   '''2'''\n:::*   a string of length   3   which contains:   '''333'''\n:::*   a string of length   3   which contains:   '''.55'''\n:::*   a string of length   6   which contains:   '''tttTTT'''\n:::*   a string of length   9   with a blank in the middle:   '''4444   444k'''\n\n\n\nShow all output here on this page.\n\n\n", "solution": "using System;\n\nnamespace AllSame {\n    class Program {\n        static void Analyze(string s) {\n            Console.WriteLine(\"Examining [{0}] which has a length of {1}:\", s, s.Length);\n            if (s.Length > 1) {\n                var b = s[0];\n                for (int i = 1; i < s.Length; i++) {\n                    var c = s[i];\n                    if (c != b) {\n                        Console.WriteLine(\"    Not all characters in the string are the same.\");\n                        Console.WriteLine(\"    '{0}' (0x{1:X02}) is different at position {2}\", c, (int)c, i);\n                        return;\n                    }\n                }\n\n            }\n            Console.WriteLine(\"    All characters in the string are the same.\");\n        }\n\n        static void Main() {\n            var strs = new string[] { \"\", \"   \", \"2\", \"333\", \".55\", \"tttTTT\", \"4444 444k\" };\n            foreach (var str in strs) {\n                Analyze(str);\n            }\n        }\n    }\n}"}
{"title": "Determine if a string has all unique characters", "language": "C sharp|C#", "task": "Given a character string   (which may be empty, or have a length of zero characters):\n::*   create a function/procedure/routine to:\n::::*    determine if all the characters in the string are unique\n::::*    indicate if or which character is duplicated and where\n::*   display each string and its length   (as the strings are being examined)\n::*   a zero-length (empty) string shall be considered as unique\n::*   process the strings from left-to-right\n::*   if       unique,   display a message saying such\n::*   if                  not unique,   then:\n::::*    display a message saying such\n::::*    display what character is duplicated\n::::*    only the 1st non-unique character need be displayed\n::::*    display where \"both\" duplicated characters are in the string\n::::*    the above messages can be part of a single message\n::::*    display the hexadecimal value of the duplicated character\n\n\n\nUse (at least) these five test values   (strings):\n:::*   a string of length     0   (an empty string)\n:::*   a string of length     1   which is a single period   ('''.''')\n:::*   a string of length     6   which contains:   '''abcABC'''\n:::*   a string of length     7   which contains a blank in the middle:   '''XYZ  ZYX'''\n:::*   a string of length         36   which   ''doesn't''   contain the letter \"oh\":\n::::::::  '''1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ'''\n\n\n\nShow all output here on this page.\n\n\n", "solution": "using System;\nusing System.Linq;\n\npublic class Program\n{\n    static void Main\n    {\n        string[] input = {\"\", \".\", \"abcABC\", \"XYZ ZYX\", \"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ\"};\n        foreach (string s in input) {\n            Console.WriteLine($\"\\\"{s}\\\" (Length {s.Length}) \" +\n                string.Join(\", \",\n                    s.Select((c, i) => (c, i))\n                    .GroupBy(t => t.c).Where(g => g.Count() > 1)\n                    .Select(g => $\"'{g.Key}' (0X{(int)g.Key:X})[{string.Join(\", \", g.Select(t => t.i))}]\")\n                    .DefaultIfEmpty(\"All characters are unique.\")\n                )\n            );\n        }\n    }\n}"}
{"title": "Determine if a string is collapsible", "language": "C sharp|C#", "task": "Determine if a character string is   ''collapsible''.\n\nAnd if so,   collapse the string   (by removing   ''immediately repeated''   characters).\n\n\n\nIf a character string has   ''immediately repeated''   character(s),   the repeated characters are to be\ndeleted (removed),   but not the primary (1st) character(s).\n\n\nAn   ''immediately repeated''   character is any character that is   immediately   followed by an\nidentical character (or characters).   Another word choice could've been   ''duplicated character'',   but that\nmight have ruled out   (to some readers)   triplicated characters   ***   or more.\n\n\n{This Rosetta Code task was inspired by a newly introduced   (as of around November 2019)   '''PL/I'''   BIF:   '''collapse'''.}\n\n\n;Examples:\nIn the following character string:\n\n\n  The better the 4-wheel drive, the further you'll be from help when ya get stuck! \n\n\nOnly the 2nd   '''t''',   '''e''', and   '''l'''   are repeated characters,   indicated\nby underscores (above),   even though they (those characters) appear elsewhere in the character string.\n\n\n\nSo, after ''collapsing'' the string, the result would be:\n\n  The beter the 4-whel drive, the further you'l be from help when ya get stuck! \n\n\n\n\nAnother example:\nIn the following character string:\n\n  headmistressship \n\n\nThe \"collapsed\" string would be:\n\n  headmistreship \n\n\n\n;Task:\nWrite a subroutine/function/procedure/routine***   to\nlocate   ''repeated''   characters and   ''collapse''   (delete)   them from the character\nstring.   The character string can be processed from either direction.\n\n\nShow all output here, on this page:\n:*   the   original string and its length\n:*   the       resultant string and its length\n:*   the above strings should be \"bracketed\" with   '''<<<'''   and   '''>>>'''   (to delineate blanks)\n;*   <<<<<<Guillemets may be used instead for \"bracketing\" for the more artistic programmers,   shown used here>>>>>>\n\n\n\n\nUse (at least) the following five strings,   all strings are length seventy-two (characters, including blanks),   except\nthe 1st string:\n\n  string\n  number\n         ++\n    1    |+-----------------------------------------------------------------------+   <######  a null string  (length zero)\n    2    |\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln |\n    3    |..1111111111111111111111111111111111111111111111111111111111111117777888|\n    4    |I never give 'em hell, I just tell the truth, and they think it's hell. |\n    5    |                                                    --- Harry S Truman  |   <######  has many repeated blanks\n         +------------------------------------------------------------------------+\n\n\n", "solution": "using System;\nusing static System.Linq.Enumerable;\n\npublic class Program\n{\n    static void Main()\n    {\n        string[] input = {\n            \"\",\n            \"The better the 4-wheel drive, the further you'll be from help when ya get stuck!\",\n            \"headmistressship\",\n            \"\\\"If I were two-faced, would I be wearing this one?\\\" --- Abraham Lincoln \",\n            \"..1111111111111111111111111111111111111111111111111111111111111117777888\",\n            \"I never give 'em hell, I just tell the truth, and they think it's hell. \",\n            \"                                                    --- Harry S Truman  \"\n        };\n        foreach (string s in input) {\n            Console.WriteLine($\"old: {s.Length} \u00ab\u00ab\u00ab{s}\u00bb\u00bb\u00bb\");\n            string c = Collapse(s);\n            Console.WriteLine($\"new: {c.Length} \u00ab\u00ab\u00ab{c}\u00bb\u00bb\u00bb\");\n        }\n    }\n\n    static string Collapse(string s) => string.IsNullOrEmpty(s) ? \"\" :\n        s[0] + new string(Range(1, s.Length - 1).Where(i => s[i] != s[i - 1]).Select(i => s[i]).ToArray());\n}"}
{"title": "Determine if a string is squeezable", "language": "C sharp|C#", "task": "Determine if a character string is   ''squeezable''.\n\nAnd if so,   squeeze the string   (by removing any number of\na   ''specified''   ''immediately repeated''   character).\n\n\nThis task is very similar to the task     '''Determine if a character string is collapsible'''     except\nthat only a specified character is   ''squeezed''   instead of any character that is ''immediately repeated''.\n\n\nIf a character string has a specified   ''immediately repeated''   character(s),   the repeated characters are to be\ndeleted (removed),   but not the primary (1st) character(s).\n\n\nA specified   ''immediately repeated''   character is any specified character that is   immediately  \nfollowed by an identical character (or characters).   Another word choice could've been   ''duplicated\ncharacter'',   but that might have ruled out   (to some readers)   triplicated characters   ***   or more.\n\n\n{This Rosetta Code task was inspired by a newly introduced   (as of around\nNovember 2019)   '''PL/I'''   BIF:   '''squeeze'''.}\n\n\n;Examples:\nIn the following character string with a specified   ''immediately repeated''   character of   '''e''':\n\n\n  The better the 4-wheel drive, the further you'll be from help when ya get stuck! \n\n\nOnly the 2nd   '''e'''   is an specified repeated character,   indicated by an underscore\n(above),   even though they (the characters) appear elsewhere in the character string.\n\n\n\nSo, after ''squeezing'' the string, the result would be:\n\n  The better the 4-whel drive, the further you'll be from help when ya get stuck! \n\n\n\n\nAnother example:\nIn the following character string,   using a specified immediately repeated character   '''s''':\n\n  headmistressship \n\n\nThe \"squeezed\" string would be:\n\n  headmistreship \n\n\n\n;Task:\nWrite a subroutine/function/procedure/routine***   to locate a   ''specified immediately repeated''   character\nand   ''squeeze''   (delete)   them from the character string.   The\ncharacter string can be processed from either direction.\n\n\nShow all output here, on this page:\n:*   the   specified repeated character   (to be searched for and possibly ''squeezed''):\n:*   the   original string and its length\n:*   the       resultant string and its length\n:*   the above strings should be \"bracketed\" with   '''<<<'''   and   '''>>>'''   (to delineate blanks)\n;*   <<<<<<Guillemets may be used instead for \"bracketing\" for the more artistic programmers,   shown used here>>>>>>\n\n\n\nUse (at least) the following five strings,   all strings are length seventy-two (characters, including blanks),   except\nthe 1st string:\n\n                                                                                   immediately\n  string                                                                            repeated\n  number                                                                            character\n                                                                                      ( |   a blank,  a minus,  a seven,  a period)\n         ++\n    1    |+-----------------------------------------------------------------------+    ' '    <######  a null string  (length zero)\n    2    |\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln |    '-'\n    3    |..1111111111111111111111111111111111111111111111111111111111111117777888|    '7'\n    4    |I never give 'em hell, I just tell the truth, and they think it's hell. |    '.'\n    5    |                                                    --- Harry S Truman  |  (below)  <######  has many repeated blanks\n         +------------------------------------------------------------------------+     |\n                                                                                        |\n                                                                                        |\n         For the 5th string  (Truman's signature line),  use each of these  specified immediately  repeated characters:\n                                   *  a blank\n                                   *  a minus\n                                   *  a lowercase  '''r'''\n\n\nNote:   there should be seven results shown,   one each for the 1st four strings,   and three results for\nthe 5th string.\n\n\n", "solution": "using System;\nusing static System.Linq.Enumerable;\n\npublic class Program\n{\n    static void Main()\n    {\n        SqueezeAndPrint(\"\", ' ');\n        SqueezeAndPrint(\"\\\"If I were two-faced, would I be wearing this one?\\\" --- Abraham Lincoln \", '-');\n        SqueezeAndPrint(\"..1111111111111111111111111111111111111111111111111111111111111117777888\", '7');\n        SqueezeAndPrint(\"I never give 'em hell, I just tell the truth, and they think it's hell. \", '.');\n        string s = \"                                                    --- Harry S Truman  \";\n        SqueezeAndPrint(s, ' ');\n        SqueezeAndPrint(s, '-');\n        SqueezeAndPrint(s, 'r');\n    }\n\n    static void SqueezeAndPrint(string s, char c) {\n        Console.WriteLine($\"squeeze: '{c}'\");\n        Console.WriteLine($\"old: {s.Length} \u00ab\u00ab\u00ab{s}\u00bb\u00bb\u00bb\");\n        s = Squeeze(s, c);\n        Console.WriteLine($\"new: {s.Length} \u00ab\u00ab\u00ab{s}\u00bb\u00bb\u00bb\");\n    }\n\n    static string Squeeze(string s, char c) => string.IsNullOrEmpty(s) ? \"\" :\n        s[0] + new string(Range(1, s.Length - 1).Where(i => s[i] != c || s[i] != s[i - 1]).Select(i => s[i]).ToArray());\n}"}
{"title": "Determine if two triangles overlap", "language": "C sharp|C#", "task": "Determining if two triangles in the same plane overlap is an important topic in collision detection.\n\n\n;Task:\nDetermine which of these pairs of triangles overlap in 2D:\n\n:::*   (0,0),(5,0),(0,5)     and   (0,0),(5,0),(0,6)\n:::*   (0,0),(0,5),(5,0)     and   (0,0),(0,5),(5,0)\n:::*   (0,0),(5,0),(0,5)     and   (-10,0),(-5,0),(-1,6)\n:::*   (0,0),(5,0),(2.5,5)        and   (0,4),(2.5,-1),(5,4)\n:::*   (0,0),(1,1),(0,2)     and   (2,1),(3,0),(3,2)\n:::*   (0,0),(1,1),(0,2)     and   (2,1),(3,-2),(3,4)\n\n\nOptionally, see what the result is when only a single corner is in contact (there is no definitive correct answer):\n:::*   (0,0),(1,0),(0,1)          and   (1,0),(2,0),(1,1)\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace TriangleOverlap {\n    class Triangle {\n        public Tuple<double, double> P1 { get; set; }\n        public Tuple<double, double> P2 { get; set; }\n        public Tuple<double, double> P3 { get; set; }\n\n        public Triangle(Tuple<double, double> p1, Tuple<double, double> p2, Tuple<double, double> p3) {\n            P1 = p1;\n            P2 = p2;\n            P3 = p3;\n        }\n\n        public double Det2D() {\n            return P1.Item1 * (P2.Item2 - P3.Item2)\n                 + P2.Item1 * (P3.Item2 - P1.Item2)\n                 + P3.Item1 * (P3.Item1 - P2.Item2);\n        }\n\n        public void CheckTriWinding(bool allowReversed) {\n            var detTri = Det2D();\n            if (detTri < 0.0) {\n                if (allowReversed) {\n                    var a = P3;\n                    P3 = P2;\n                    P2 = a;\n                } else {\n                    throw new Exception(\"Triangle has wrong winding direction\");\n                }\n            }\n        }\n\n        public bool BoundaryCollideChk(double eps) {\n            return Det2D() < eps;\n        }\n\n        public bool BoundaryDoesntCollideChk(double eps) {\n            return Det2D() <= eps;\n        }\n\n        public override string ToString() {\n            return string.Format(\"Triangle: {0}, {1}, {2}\", P1, P2, P3);\n        }\n    }\n\n    class Program {\n        static bool BoundaryCollideChk(Triangle t, double eps) {\n            return t.BoundaryCollideChk(eps);\n        }\n\n        static bool BoundaryDoesntCollideChk(Triangle t, double eps) {\n            return t.BoundaryDoesntCollideChk(eps);\n        }\n\n        static bool TriTri2D(Triangle t1, Triangle t2, double eps = 0.0, bool allowReversed = false, bool onBoundary = true) {\n            // Triangles must be expressed anti-clockwise\n            t1.CheckTriWinding(allowReversed);\n            t2.CheckTriWinding(allowReversed);\n            // 'onBoundary' determines whether points on boundary are considered as colliding or not\n            var chkEdge = onBoundary\n                ? (Func<Triangle, double, bool>)BoundaryCollideChk\n                : BoundaryDoesntCollideChk;\n            List<Tuple<double, double>> lp1 = new List<Tuple<double, double>>() { t1.P1, t1.P2, t1.P3 };\n            List<Tuple<double, double>> lp2 = new List<Tuple<double, double>>() { t2.P1, t2.P2, t2.P3 };\n\n            // for each edge E of t1\n            for (int i = 0; i < 3; i++) {\n                var j = (i + 1) % 3;\n                // Check all points of t2 lay on the external side of edge E.\n                // If they do, the triangles do not overlap.\n                if (chkEdge(new Triangle(lp1[i], lp1[j], lp2[0]), eps) &&\n                    chkEdge(new Triangle(lp1[i], lp1[j], lp2[1]), eps) &&\n                    chkEdge(new Triangle(lp1[i], lp1[j], lp2[2]), eps)) {\n                    return false;\n                }\n            }\n\n            // for each edge E of t2\n            for (int i = 0; i < 3; i++) {\n                var j = (i + 1) % 3;\n                // Check all points of t1 lay on the external side of edge E.\n                // If they do, the triangles do not overlap.\n                if (chkEdge(new Triangle(lp2[i], lp2[j], lp1[0]), eps) &&\n                    chkEdge(new Triangle(lp2[i], lp2[j], lp1[1]), eps) &&\n                    chkEdge(new Triangle(lp2[i], lp2[j], lp1[2]), eps)) {\n                    return false;\n                }\n            }\n\n            // The triangles overlap\n            return true;\n        }\n\n        static void Overlap(Triangle t1, Triangle t2, double eps = 0.0, bool allowReversed = false, bool onBoundary = true) {\n            if (TriTri2D(t1, t2, eps, allowReversed, onBoundary)) {\n                Console.WriteLine(\"overlap\");\n            } else {\n                Console.WriteLine(\"do not overlap\");\n            }\n        }\n\n        static void Main(string[] args) {\n            var t1 = new Triangle(new Tuple<double, double>(0.0, 0.0), new Tuple<double, double>(5.0, 0.0), new Tuple<double, double>(0.0, 5.0));\n            var t2 = new Triangle(new Tuple<double, double>(0.0, 0.0), new Tuple<double, double>(5.0, 0.0), new Tuple<double, double>(0.0, 6.0));\n            Console.WriteLine(\"{0} and\\n{1}\", t1, t2);\n            Overlap(t1, t2);\n            Console.WriteLine();\n\n            // need to allow reversed for this pair to avoid exception\n            t1 = new Triangle(new Tuple<double, double>(0.0, 0.0), new Tuple<double, double>(0.0, 5.0), new Tuple<double, double>(5.0, 0.0));\n            t2 = t1;\n            Console.WriteLine(\"{0} and\\n{1}\", t1, t2);\n            Overlap(t1, t2, 0.0, true);\n            Console.WriteLine();\n\n            t1 = new Triangle(new Tuple<double, double>(0.0, 0.0), new Tuple<double, double>(5.0, 0.0), new Tuple<double, double>(0.0, 5.0));\n            t2 = new Triangle(new Tuple<double, double>(-10.0, 0.0), new Tuple<double, double>(-5.0, 0.0), new Tuple<double, double>(-1.0, 6.0));\n            Console.WriteLine(\"{0} and\\n{1}\", t1, t2);\n            Overlap(t1, t2);\n            Console.WriteLine();\n\n            t1.P3 = new Tuple<double, double>(2.5, 5.0);\n            t2 = new Triangle(new Tuple<double, double>(0.0, 4.0), new Tuple<double, double>(2.5, -1.0), new Tuple<double, double>(5.0, 4.0));\n            Console.WriteLine(\"{0} and\\n{1}\", t1, t2);\n            Overlap(t1, t2);\n            Console.WriteLine();\n\n            t1 = new Triangle(new Tuple<double, double>(0.0, 0.0), new Tuple<double, double>(1.0, 1.0), new Tuple<double, double>(0.0, 2.0));\n            t2 = new Triangle(new Tuple<double, double>(2.0, 1.0), new Tuple<double, double>(3.0, 0.0), new Tuple<double, double>(3.0, 2.0));\n            Console.WriteLine(\"{0} and\\n{1}\", t1, t2);\n            Overlap(t1, t2);\n            Console.WriteLine();\n\n            t2 = new Triangle(new Tuple<double, double>(2.0, 1.0), new Tuple<double, double>(3.0, -2.0), new Tuple<double, double>(3.0, 4.0));\n            Console.WriteLine(\"{0} and\\n{1}\", t1, t2);\n            Overlap(t1, t2);\n            Console.WriteLine();\n\n            t1 = new Triangle(new Tuple<double, double>(0.0, 0.0), new Tuple<double, double>(1.0, 0.0), new Tuple<double, double>(0.0, 1.0));\n            t2 = new Triangle(new Tuple<double, double>(1.0, 0.0), new Tuple<double, double>(2.0, 0.0), new Tuple<double, double>(1.0, 1.1));\n            Console.WriteLine(\"{0} and\\n{1}\", t1, t2);\n            Console.WriteLine(\"which have only a single corner in contact, if boundary points collide\");\n            Overlap(t1, t2);\n            Console.WriteLine();\n\n            Console.WriteLine(\"{0} and\\n{1}\", t1, t2);\n            Console.WriteLine(\"which have only a single corner in contact, if boundary points do not collide\");\n            Overlap(t1, t2, 0.0, false, false);\n        }\n    }\n}"}
{"title": "Digital root", "language": "C sharp|C#", "task": "The digital root, X, of a number, n, is calculated:\n: find X as the sum of the digits of n\n: find a new X by summing the digits of X, repeating until X has only one digit.\n\nThe additive persistence is the number of summations required to obtain the single digit. \n\nThe task is to calculate the additive persistence and the digital root of a number, e.g.:\n:627615 has additive persistence 2 and digital root of 9;\n:39390 has additive persistence 2 and digital root of 6;\n:588225 has additive persistence 2 and digital root of 3;\n:393900588225 has additive persistence 2 and digital root of 9;\n\nThe digital root may be calculated in bases other than 10.\n\n\n;See:\n* [[Casting out nines]] for this wiki's use of this procedure.\n* [[Digital root/Multiplicative digital root]]\n* [[Sum digits of an integer]]\n* Digital root sequence on OEIS\n* Additive persistence sequence on OEIS\n* [[Iterated digits squaring]]\n\n", "solution": "using System;\nusing System.Linq;\n\nclass Program\n{\n    static Tuple<int, int> DigitalRoot(long num)\n    {\n        int additivepersistence = 0;\n        while (num > 9)\n        {\n            num = num.ToString().ToCharArray().Sum(x => x - '0');\n            additivepersistence++;\n        }\n        return new Tuple<int, int>(additivepersistence, (int)num);\n    }\n    static void Main(string[] args)\n    {\n        foreach (long num in new long[] { 627615, 39390, 588225, 393900588225 })\n        {\n            var t = DigitalRoot(num);\n            Console.WriteLine(\"{0} has additive persistence {1} and digital root {2}\", num, t.Item1, t.Item2);\n        }\n    }\n}"}
{"title": "Display a linear combination", "language": "C sharp|C# from D", "task": "Display a finite linear combination in an infinite vector basis (e_1, e_2,\\ldots).\n\nWrite a function that, when given a finite list of scalars (\\alpha^1,\\alpha^2,\\ldots), creates a string representing the linear combination \\sum_i\\alpha^i e_i in an explicit format often used in mathematics, that is:\n\n:\\alpha^{i_1}e_{i_1}\\pm|\\alpha^{i_2}|e_{i_2}\\pm|\\alpha^{i_3}|e_{i_3}\\pm\\ldots\n\nwhere \\alpha^{i_k}\\neq 0\n\nThe output must comply to the following rules:\n*   don't show null terms, unless the whole combination is null. \n:::::::  '''e(1)'''     is fine,     '''e(1) + 0*e(3)'''     or     '''e(1) + 0'''     is wrong.\n*   don't show scalars when they are equal to one or minus one. \n:::::::  '''e(3)'''     is fine,     '''1*e(3)'''     is wrong.\n*   don't prefix by a minus sign if it follows a preceding term.   Instead you use subtraction. \n:::::::  '''e(4) - e(5)'''     is fine,     '''e(4) + -e(5)'''     is wrong.\n\n\nShow here output for the following lists of scalars:\n\n 1)    1,  2,  3\n 2)    0,  1,  2,  3\n 3)    1,  0,  3,  4\n 4)    1,  2,  0\n 5)    0,  0,  0\n 6)    0\n 7)    1,  1,  1\n 8)   -1, -1, -1\n 9)   -1, -2,  0, -3\n10)   -1\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Text;\n\nnamespace DisplayLinearCombination {\n    class Program {\n        static string LinearCombo(List<int> c) {\n            StringBuilder sb = new StringBuilder();\n            for (int i = 0; i < c.Count; i++) {\n                int n = c[i];\n                if (n < 0) {\n                    if (sb.Length == 0) {\n                        sb.Append('-');\n                    } else {\n                        sb.Append(\" - \");\n                    }\n                } else if (n > 0) {\n                    if (sb.Length != 0) {\n                        sb.Append(\" + \");\n                    }\n                } else {\n                    continue;\n                }\n\n                int av = Math.Abs(n);\n                if (av != 1) {\n                    sb.AppendFormat(\"{0}*\", av);\n                }\n                sb.AppendFormat(\"e({0})\", i + 1);\n            }\n            if (sb.Length == 0) {\n                sb.Append('0');\n            }\n            return sb.ToString();\n        }\n\n        static void Main(string[] args) {\n            List<List<int>> combos = new List<List<int>>{\n                new List<int> { 1, 2, 3},\n                new List<int> { 0, 1, 2, 3},\n                new List<int> { 1, 0, 3, 4},\n                new List<int> { 1, 2, 0},\n                new List<int> { 0, 0, 0},\n                new List<int> { 0},\n                new List<int> { 1, 1, 1},\n                new List<int> { -1, -1, -1},\n                new List<int> { -1, -2, 0, -3},\n                new List<int> { -1},\n            };\n\n            foreach (List<int> c in combos) {\n                var arr = \"[\" + string.Join(\", \", c) + \"]\";\n                Console.WriteLine(\"{0,15} -> {1}\", arr, LinearCombo(c));\n            }\n        }\n    }\n}"}
{"title": "Diversity prediction theorem", "language": "C sharp|C#", "task": "The   ''wisdom of the crowd''   is the collective opinion of a group of individuals rather than that of a single expert.\n\nWisdom-of-the-crowds research routinely attributes the superiority of crowd averages over individual judgments to the elimination of individual noise,   an explanation that assumes independence of the individual judgments from each other. \n\nThus the crowd tends to make its best decisions if it is made up of diverse opinions and ideologies.\n\n\nScott E. Page introduced the diversity prediction theorem: \n: ''The squared error of the collective prediction equals the average squared error minus the predictive diversity''. \n\n\nTherefore,   when the diversity in a group is large,   the error of the crowd is small.\n\n\n;Definitions:\n::*   Average Individual Error:   Average of the individual squared errors\n::*   Collective Error:           Squared error of the collective prediction\n::*   Prediction Diversity:       Average squared distance from the individual predictions to the collective prediction\n::*   Diversity Prediction Theorem:   ''Given a crowd of predictive models'',     then\n::::::   Collective Error   =   Average Individual Error   -   Prediction Diversity\n\n;Task:\nFor a given   true   value and a number of number of estimates (from a crowd),   show   (here on this page):\n:::*   the true value   and   the crowd estimates\n:::*   the average error\n:::*   the crowd error\n:::*   the prediction diversity\n\n\nUse   (at least)   these two examples:\n:::*   a true value of   '''49'''   with crowd estimates of:   ''' 48   47   51'''\n:::*   a true value of   '''49'''   with crowd estimates of:   ''' 48   47   51   42'''\n\n\n\n;Also see:\n:*   Wikipedia entry:   Wisdom of the crowd\n:*   University of Michigan: PDF paper         (exists on a web archive,   the ''Wayback Machine'').\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\npublic class MainClass {\n    static double Square(double x) => x * x;\n\n    static double AverageSquareDiff(double a, IEnumerable<double> predictions)\n        => predictions.Select(x => Square(x - a)).Average();\n\n    static void DiversityTheorem(double truth, IEnumerable<double> predictions)\n    {\n        var average = predictions.Average();\n        Console.WriteLine($@\"average-error: {AverageSquareDiff(truth, predictions)}\ncrowd-error: {Square(truth - average)}\ndiversity: {AverageSquareDiff(average, predictions)}\");\n    }\n\t\n    public static void Main() {\n\tDiversityTheorem(49, new []{48d,47,51});\n    \tDiversityTheorem(49, new []{48d,47,51,42});\n    }\n}"}
{"title": "Dot product", "language": "C sharp|C#", "task": "Create a function/use an in-built function, to compute the   '''dot product''',   also known as the   '''scalar product'''   of two vectors. \n\nIf possible, make the vectors of arbitrary length.\n\n\nAs an example, compute the dot product of the vectors:\n::::     [1,  3, -5]       and \n::::     [4,      -2, -1]  \n\nIf implementing the dot product of two vectors directly:\n:::*   each vector must be the same length\n:::*   multiply corresponding terms from each vector\n:::*   sum the products   (to produce the answer)\n\n\n;Related task:\n*   [[Vector products]]\n\n", "solution": "static void Main(string[] args)\n{\n\tConsole.WriteLine(DotProduct(new decimal[] { 1, 3, -5 }, new decimal[] { 4, -2, -1 }));\n\tConsole.Read();\n}\n\nprivate static decimal DotProduct(decimal[] vec1, decimal[] vec2) \n{\n\tif (vec1 == null)\n\t\treturn 0;\n\n\tif (vec2 == null)\n\t\treturn 0;\n\n\tif (vec1.Length != vec2.Length)\n\t\treturn 0;\n\n\tdecimal tVal = 0;\n\tfor (int x = 0; x < vec1.Length; x++)\n\t{\n\t\ttVal += vec1[x] * vec2[x];\n\t}\n\n\treturn tVal;\n}"}
{"title": "Dot product", "language": "C sharp", "task": "Create a function/use an in-built function, to compute the   '''dot product''',   also known as the   '''scalar product'''   of two vectors. \n\nIf possible, make the vectors of arbitrary length.\n\n\nAs an example, compute the dot product of the vectors:\n::::     [1,  3, -5]       and \n::::     [4,      -2, -1]  \n\nIf implementing the dot product of two vectors directly:\n:::*   each vector must be the same length\n:::*   multiply corresponding terms from each vector\n:::*   sum the products   (to produce the answer)\n\n\n;Related task:\n*   [[Vector products]]\n\n", "solution": "public static decimal DotProduct(decimal[] a, decimal[] b) {\n    return a.Zip(b, (x, y) => x * y).Sum();\n}"}
{"title": "Draw a clock", "language": "C sharp|C#", "task": "Draw a clock.  \n\n\nMore specific:\n# Draw a time keeping device. It can be a stopwatch, hourglass, sundial, a mouth counting \"one thousand and one\", anything. Only showing the seconds is required, e.g.: a watch with just a second hand will suffice. However, it must clearly change every second, and the change must cycle every so often (one minute, 30 seconds, etc.) It must be ''drawn''; printing a string of numbers to your terminal doesn't qualify. Both text-based and graphical drawing are OK.\n# The clock is unlikely to be used to control space flights, so it needs not be hyper-accurate, but it should be usable, meaning if one can read the seconds off the clock, it must agree with the system clock.\n# A clock is rarely (never?) a major application: don't be a CPU hog and poll the system timer every microsecond, use a proper timer/signal/event from your system or language instead. For a bad example, many OpenGL programs update the frame-buffer in a busy loop even if no redraw is needed, which is very undesirable for this task.\n# A clock is rarely (never?) a major application: try to keep your code simple and to the point. Don't write something too elaborate or convoluted, instead do whatever is natural, concise and clear in your language.\n\n\n;Key points\n* animate simple object\n* timed event \n* polling system resources \n* code clarity\n\n", "solution": "using System;\nusing System.Drawing;\nusing System.Drawing.Drawing2D;\nusing System.Windows.Forms;\n\npublic class Clock : Form\n{\n    static readonly float degrees06 = (float)Math.PI / 30;\n    static readonly float degrees30 = degrees06 * 5;\n    static readonly float degrees90 = degrees30 * 3;\n\n    readonly int margin = 20;\n\n    private Point p0;\n\n    public Clock()\n    {\n        Size = new Size(500, 500);\n        StartPosition = FormStartPosition.CenterScreen;\n        Resize += (sender, args) => ResetSize();\n        ResetSize();\n        var timer = new Timer() { Interval = 1000, Enabled = true };\n        timer.Tick += (sender, e) => Refresh();\n        DoubleBuffered = true;\n    }\n\n    private void ResetSize()\n    {\n        p0 = new Point(ClientRectangle.Width / 2, ClientRectangle.Height / 2);\n        Refresh();\n    }\n\n    protected override void OnPaint(PaintEventArgs e)\n    {\n        base.OnPaint(e);\n        e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;\n\n        drawFace(e.Graphics);\n\n        var time = DateTime.Now;\n        int second = time.Second;\n        int minute = time.Minute;\n        int hour = time.Hour;\n\n        float angle = degrees90 - (degrees06 * second);\n        DrawHand(e.Graphics, Pens.Red, angle, 0.95);\n\n        float minsecs = (minute + second / 60.0F);\n        angle = degrees90 - (degrees06 * minsecs);\n        DrawHand(e.Graphics, Pens.Black, angle, 0.9);\n\n        float hourmins = (hour + minsecs / 60.0F);\n        angle = degrees90 - (degrees30 * hourmins);\n        DrawHand(e.Graphics, Pens.Black, angle, 0.6);\n    }\n\n    private void drawFace(Graphics g)\n    {\n        int radius = Math.Min(p0.X, p0.Y) - margin;\n        g.FillEllipse(Brushes.White, p0.X - radius, p0.Y - radius, radius * 2, radius * 2);\n\n        for (int h = 0; h < 12; h++)\n            DrawHand(g, Pens.LightGray, h * degrees30, -0.05);\n\n        for (int m = 0; m < 60; m++)\n            DrawHand(g, Pens.LightGray, m * degrees06, -0.025);\n    }\n\n    private void DrawHand(Graphics g, Pen pen, float angle, double size)\n    {\n        int radius = Math.Min(p0.X, p0.Y) - margin;\n\n        int x0 = p0.X + (size > 0 ? 0 : Convert.ToInt32(radius * (1 + size) * Math.Cos(angle)));\n        int y0 = p0.Y + (size > 0 ? 0 : Convert.ToInt32(radius * (1 + size) * Math.Sin(-angle)));\n\n        int x1 = p0.X + Convert.ToInt32(radius * (size > 0 ? size : 1) * Math.Cos(angle));\n        int y1 = p0.Y + Convert.ToInt32(radius * (size > 0 ? size : 1) * Math.Sin(-angle));\n\n        g.DrawLine(pen, x0, y0, x1, y1);\n    }\n\n    [STAThread]\n    static void Main()\n    {\n        Application.Run(new Clock());\n    }\n}"}
{"title": "Draw a rotating cube", "language": "C sharp|C# from Java", "task": "Task\nDraw a rotating cube. \n\nIt should be oriented with one vertex pointing straight up, and its opposite vertex on the main diagonal (the one farthest away) straight down. It can be solid or wire-frame, and you can use ASCII art if your language doesn't have graphical capabilities. Perspective is optional.\n\n\n;Related tasks\n* Draw a cuboid\n* write language name in 3D ASCII\n\n", "solution": "using System;\nusing System.Drawing;\nusing System.Drawing.Drawing2D;\nusing System.Windows.Forms;\nusing System.Windows.Threading;\n\nnamespace RotatingCube\n{\n    public partial class Form1 : Form\n    {\n        double[][] nodes = {\n            new double[] {-1, -1, -1}, new double[] {-1, -1, 1}, new double[] {-1, 1, -1},\n            new double[] {-1, 1, 1}, new double[] {1, -1, -1}, new double[] {1, -1, 1},\n            new double[] {1, 1, -1}, new double[] {1, 1, 1} };\n\n        int[][] edges = {\n            new int[] {0, 1}, new int[] {1, 3}, new int[] {3, 2}, new int[] {2, 0}, new int[] {4, 5},\n            new int[] {5, 7}, new int[] {7, 6}, new int[] {6, 4}, new int[] {0, 4}, new int[] {1, 5},\n            new int[] {2, 6}, new int[] {3, 7}};\n\n        public Form1()\n        {\n            Width = Height = 640;\n            StartPosition = FormStartPosition.CenterScreen;\n            SetStyle(\n                ControlStyles.AllPaintingInWmPaint |\n                ControlStyles.UserPaint |\n                ControlStyles.DoubleBuffer,\n                true);\n\n            Scale(100, 100, 100);\n            RotateCuboid(Math.PI / 4, Math.Atan(Math.Sqrt(2)));\n\n            var timer = new DispatcherTimer();\n            timer.Tick += (s, e) => { RotateCuboid(Math.PI / 180, 0); Refresh(); };\n            timer.Interval = new TimeSpan(0, 0, 0, 0, 17);\n            timer.Start();\n        }\n\n        private void RotateCuboid(double angleX, double angleY)\n        {\n            double sinX = Math.Sin(angleX);\n            double cosX = Math.Cos(angleX);\n\n            double sinY = Math.Sin(angleY);\n            double cosY = Math.Cos(angleY);\n\n            foreach (var node in nodes)\n            {\n                double x = node[0];\n                double y = node[1];\n                double z = node[2];\n\n                node[0] = x * cosX - z * sinX;\n                node[2] = z * cosX + x * sinX;\n\n                z = node[2];\n\n                node[1] = y * cosY - z * sinY;\n                node[2] = z * cosY + y * sinY;\n            }\n        }\n\n        private void Scale(int v1, int v2, int v3)\n        {\n            foreach (var item in nodes)\n            {\n                item[0] *= v1;\n                item[1] *= v2;\n                item[2] *= v3;\n            }\n        }\n\n        protected override void OnPaint(PaintEventArgs args)\n        {\n            var g = args.Graphics;\n            g.SmoothingMode = SmoothingMode.HighQuality;\n            g.Clear(Color.White);\n\n            g.TranslateTransform(Width / 2, Height / 2);\n\n            foreach (var edge in edges)\n            {\n                double[] xy1 = nodes[edge[0]];\n                double[] xy2 = nodes[edge[1]];\n                g.DrawLine(Pens.Black, (int)Math.Round(xy1[0]), (int)Math.Round(xy1[1]),\n                        (int)Math.Round(xy2[0]), (int)Math.Round(xy2[1]));\n            }\n\n            foreach (var node in nodes)\n            {\n                g.FillEllipse(Brushes.Black, (int)Math.Round(node[0]) - 4,\n                    (int)Math.Round(node[1]) - 4, 8, 8);\n            }\n        }\n    }\n}"}
{"title": "Draw a sphere", "language": "C sharp|C# from C", "task": "{{requires|Graphics}}\n\n\n;Task:\nDraw a sphere. \n\nThe sphere can be represented graphically, or in ASCII art, depending on the language capabilities. \n\nEither static or rotational projection is acceptable for this task.\n\n\n;Related tasks:\n* draw a cuboid\n* draw a rotating cube\n* write language name in 3D ASCII\n* draw a Deathstar\n\n", "solution": "using System;\n\nnamespace Sphere {\n    internal class Program {\n        private const string Shades = \".:!*oe%&#@\";\n        private static readonly double[] Light = {30, 30, -50};\n\n        private static void Normalize(double[] v) {\n            double len = Math.Sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);\n            v[0] /= len;\n            v[1] /= len;\n            v[2] /= len;\n        }\n\n        private static double Dot(double[] x, double[] y) {\n            double d = x[0]*y[0] + x[1]*y[1] + x[2]*y[2];\n            return d < 0 ? -d : 0;\n        }\n\n        public static void DrawSphere(double r, double k, double ambient) {\n            var vec = new double[3];\n            for(var i = (int)Math.Floor(-r); i <= (int)Math.Ceiling(r); i++) {\n                double x = i + .5;\n                for(var j = (int)Math.Floor(-2*r); j <= (int)Math.Ceiling(2*r); j++) {\n                    double y = j/2.0 + .5;\n                    if(x*x + y*y <= r*r) {\n                        vec[0] = x;\n                        vec[1] = y;\n                        vec[2] = Math.Sqrt(r*r - x*x - y*y);\n                        Normalize(vec);\n                        double b = Math.Pow(Dot(Light, vec), k) + ambient;\n                        int intensity = (b <= 0)\n                                            ? Shades.Length - 2\n                                            : (int)Math.Max((1 - b)*(Shades.Length - 1), 0);\n                        Console.Write(Shades[intensity]);\n                    }\n                    else\n                        Console.Write(' ');\n                }\n                Console.WriteLine();\n            }\n        }\n\n        private static void Main() {\n            Normalize(Light);\n            DrawSphere(6, 4, .1);\n            DrawSphere(10, 2, .4);\n            Console.ReadKey();\n        }\n    }\n}"}
{"title": "Eban numbers", "language": "C sharp|C# from D", "task": "Definition:\nAn   '''eban'''   number is a number that has no letter    '''e'''    in it when the number is spelled in English.\n\nOr more literally,   spelled numbers that contain the letter   '''e'''   are banned.\n\n\nThe American version of spelling numbers will be used here   (as opposed to the British).\n\n'''2,000,000,000'''   is two billion,   ''not''   two milliard.\n\n\nOnly numbers less than   '''one sextillion'''   ('''1021''')   will be considered in/for this task.\n\nThis will allow optimizations to be used.\n\n\n\n;Task:\n:::*   show all eban numbers   <=   '''1,000'''   (in a horizontal format),                   and a count\n:::*   show all eban numbers between   '''1,000'''   and   '''4,000'''   (inclusive),   and a count\n:::*   show a count of all eban numbers up and including            '''10,000'''\n:::*   show a count of all eban numbers up and including                '''100,000'''\n:::*   show a count of all eban numbers up and including                   '''1,000,000'''\n:::*   show a count of all eban numbers up and including                      '''10,000,000'''\n:::*   show all output here.\n\n\n;See also:\n:*   The MathWorld entry:    eban numbers.\n:*   The OEIS      entry:   A6933,                eban numbers.\n:*   [[Number names]].\n\n", "solution": "using System;\n\nnamespace EbanNumbers {\n    struct Interval {\n        public int start, end;\n        public bool print;\n\n        public Interval(int start, int end, bool print) {\n            this.start = start;\n            this.end = end;\n            this.print = print;\n        }\n    }\n\n    class Program {\n        static void Main() {\n            Interval[] intervals = {\n                new Interval(2, 1_000, true),\n                new Interval(1_000, 4_000, true),\n                new Interval(2, 10_000, false),\n                new Interval(2, 100_000, false),\n                new Interval(2, 1_000_000, false),\n                new Interval(2, 10_000_000, false),\n                new Interval(2, 100_000_000, false),\n                new Interval(2, 1_000_000_000, false),\n            };\n            foreach (var intv in intervals) {\n                if (intv.start == 2) {\n                    Console.WriteLine(\"eban numbers up to and including {0}:\", intv.end);\n                } else {\n                    Console.WriteLine(\"eban numbers between {0} and {1} (inclusive):\", intv.start, intv.end);\n                }\n\n                int count = 0;\n                for (int i = intv.start; i <= intv.end; i += 2) {\n                    int b = i / 1_000_000_000;\n                    int r = i % 1_000_000_000;\n                    int m = r / 1_000_000;\n                    r = i % 1_000_000;\n                    int t = r / 1_000;\n                    r %= 1_000;\n                    if (m >= 30 && m <= 66) m %= 10;\n                    if (t >= 30 && t <= 66) t %= 10;\n                    if (r >= 30 && r <= 66) r %= 10;\n                    if (b == 0 || b == 2 || b == 4 || b == 6) {\n                        if (m == 0 || m == 2 || m == 4 || m == 6) {\n                            if (t == 0 || t == 2 || t == 4 || t == 6) {\n                                if (r == 0 || r == 2 || r == 4 || r == 6) {\n                                    if (intv.print) Console.Write(\"{0} \", i);\n                                    count++;\n                                }\n                            }\n                        }\n                    }\n                }\n                if (intv.print) {\n                    Console.WriteLine();\n                }\n                Console.WriteLine(\"count = {0}\\n\", count);\n            }\n        }\n    }\n}"}
{"title": "Eertree", "language": "C sharp|C# from Java", "task": "An '''eertree''' is a data structure designed for efficient processing of certain palindrome tasks, for instance counting the number of sub-palindromes in an input string. \n\nThe data structure has commonalities to both ''tries'' and ''suffix trees''.\n  See links below. \n\n\n;Task:\nConstruct an eertree for the string \"eertree\", then output all sub-palindromes by traversing the tree.\n\n\n;See also:\n*   Wikipedia entry:   trie.\n*   Wikipedia entry:   suffix tree \n*   Cornell University Library, Computer Science, Data Structures and Algorithms ---> EERTREE: An Efficient Data Structure for Processing Palindromes in Strings.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace Eertree {\n    class Node {\n        public Node(int length) {\n            this.Length = length;\n            // empty or\n            this.Edges = new Dictionary<char, int>();\n        }\n\n        public Node(int length, Dictionary<char, int> edges, int suffix) {\n            this.Length = length;\n            this.Edges = edges;\n            this.Suffix = suffix;\n        }\n\n        public int Length { get; set; }\n        public Dictionary<char, int> Edges { get; set; }\n        public int Suffix { get; set; }\n    }\n\n    class Program {\n        const int EVEN_ROOT = 0;\n        const int ODD_ROOT = 1;\n\n        static List<Node> Eertree(string s) {\n            List<Node> tree = new List<Node> {\n                //new Node(0, null, ODD_ROOT), or\n                new Node(0, new Dictionary<char, int>(), ODD_ROOT),\n                //new Node(-1, null, ODD_ROOT) or\n                new Node(-1, new Dictionary<char, int>(), ODD_ROOT)\n            };\n            int suffix = ODD_ROOT;\n            int n, k;\n            for (int i = 0; i < s.Length; i++) {\n                char c = s[i];\n                for (n = suffix; ; n = tree[n].Suffix) {\n                    k = tree[n].Length;\n                    int b = i - k - 1;\n                    if (b >= 0 && s[b] == c) {\n                        break;\n                    }\n                }\n                if (tree[n].Edges.ContainsKey(c)) {\n                    suffix = tree[n].Edges[c];\n                    continue;\n                }\n                suffix = tree.Count;\n                tree.Add(new Node(k + 2));\n                tree[n].Edges[c] = suffix;\n                if (tree[suffix].Length == 1) {\n                    tree[suffix].Suffix = 0;\n                    continue;\n                }\n                while (true) {\n                    n = tree[n].Suffix;\n                    int b = i - tree[n].Length - 1;\n                    if (b >= 0 && s[b] == c) {\n                        break;\n                    }\n                }\n                tree[suffix].Suffix = tree[n].Edges[c];\n            }\n            return tree;\n        }\n\n        static List<string> SubPalindromes(List<Node> tree) {\n            List<string> s = new List<string>();\n            SubPalindromes_children(0, \"\", tree, s);\n            foreach (var c in tree[1].Edges.Keys) {\n                int m = tree[1].Edges[c];\n                string ct = c.ToString();\n                s.Add(ct);\n                SubPalindromes_children(m, ct, tree, s);\n            }\n            return s;\n        }\n\n        static void SubPalindromes_children(int n, string p, List<Node> tree, List<string> s) {\n            foreach (var c in tree[n].Edges.Keys) {\n                int m = tree[n].Edges[c];\n                string p1 = c + p + c;\n                s.Add(p1);\n                SubPalindromes_children(m, p1, tree, s);\n            }\n        }\n\n        static void Main(string[] args) {\n            List<Node> tree = Eertree(\"eertree\");\n            List<string> result = SubPalindromes(tree);\n            string listStr = string.Join(\", \", result);\n            Console.WriteLine(\"[{0}]\", listStr);\n        }\n    }\n}"}
{"title": "Egyptian division", "language": "C sharp|C#", "task": "Egyptian division is a method of dividing integers using addition and \ndoubling that is similar to the algorithm of [[Ethiopian multiplication]]\n\n'''Algorithm:'''\n\nGiven two numbers where the '''dividend''' is to be divided by the '''divisor''':\n\n# Start the construction of a table of two columns: '''powers_of_2''', and '''doublings'''; by a first row of a 1 (i.e. 2^0) in the first column and 1 times the divisor in the first row second column.\n# Create the second row with columns of 2 (i.e 2^1), and 2 * divisor in order.\n# Continue with successive i'th rows of 2^i and 2^i * divisor.\n# Stop adding rows, and keep only those rows, where 2^i * divisor is less than or equal to the dividend.\n# We now assemble two separate sums that both start as zero, called here '''answer''' and '''accumulator'''\n# Consider each row of the table, in the ''reverse'' order of its construction.\n# If the current value of the accumulator added to the doublings cell would be less than or equal to the dividend then add it to the accumulator, as well as adding the powers_of_2 cell value to the answer.\n# When the first row has been considered as above, then the integer division of dividend by divisor is given by answer. (And the remainder is given by the absolute value of accumulator - dividend).\n\n\n'''Example: 580 / 34'''\n\n''' Table creation: '''\n\n::: {| class=\"wikitable\"\n! powers_of_2\n! doublings\n|-\n| 1\n| 34\n|-\n| 2\n| 68\n|-\n| 4\n| 136\n|-\n| 8\n| 272\n|-\n| 16\n| 544\n|}\n\n''' Initialization of sums: '''\n\n::: {| class=\"wikitable\"\n! powers_of_2\n! doublings\n! answer\n! accumulator\n|-\n| 1\n| 34\n|\n\n|\n\n|-\n| 2\n| 68\n|\n\n|\n\n|-\n| 4\n| 136\n|\n\n|\n\n|-\n| 8\n| 272\n|\n\n|\n\n|-\n| 16\n| 544\n|\n\n|\n\n|-\n|\n|\n| 0\n| 0\n|}\n\n''' Considering table rows, bottom-up: '''\n\nWhen a row is considered it is shown crossed out if it is not accumulated, or '''bold''' if the row causes summations.\n\n::: {| class=\"wikitable\"\n! powers_of_2\n! doublings\n! answer\n! accumulator\n|-\n| 1\n| 34\n|\n\n|\n\n|-\n| 2\n| 68\n|\n\n|\n\n|-\n| 4\n| 136\n|\n\n|\n\n|-\n| 8\n| 272\n|\n\n|\n\n|-\n| '''16'''\n| '''544'''\n| 16\n| 544\n|}\n\n::: {| class=\"wikitable\"\n! powers_of_2\n! doublings\n! answer\n! accumulator\n|-\n| 1\n| 34\n|\n\n|\n\n|-\n| 2\n| 68\n|\n\n|\n\n|-\n| 4\n| 136\n|\n\n|\n\n|-\n| 8\n| 272\n| 16\n| 544\n|-\n| '''16'''\n| '''544'''\n|\n\n|\n\n|}\n\n::: {| class=\"wikitable\"\n! powers_of_2\n! doublings\n! answer\n! accumulator\n|-\n| 1\n| 34\n|\n\n|\n\n|-\n| 2\n| 68\n|\n\n|\n\n|-\n| 4\n| 136\n| 16\n| 544\n|-\n| 8\n| 272\n|\n\n|\n\n|-\n| '''16'''\n| '''544'''\n|\n\n|\n\n|}\n\n::: {| class=\"wikitable\"\n! powers_of_2\n! doublings\n! answer\n! accumulator\n|-\n| 1\n| 34\n|\n\n|\n\n|-\n| 2\n| 68\n| 16\n| 544\n|-\n| 4\n| 136\n|\n\n|\n\n|-\n| 8\n| 272\n|\n\n|\n\n|-\n| '''16'''\n| '''544'''\n|\n\n|\n\n|}\n\n::: {| class=\"wikitable\"\n! powers_of_2\n! doublings\n! answer\n! accumulator\n|-\n| '''1'''\n| '''34'''\n| 17\n| 578\n|-\n| 2\n| 68\n|\n\n|\n\n|-\n| 4\n| 136\n|\n\n|\n\n|-\n| 8\n| 272\n|\n\n|\n\n|-\n| '''16'''\n| '''544'''\n|\n\n|\n\n|}\n\n;Answer:\nSo 580 divided by 34 using the Egyptian method is '''17''' remainder (578 - 580) or '''2'''.\n\n\n;Task:\nThe task is to create a function that does Egyptian division. The function should\nclosely follow the description above in using a list/array of powers of two, and\nanother of doublings.\n\n* Functions should be clear interpretations of the algorithm.\n* Use the function to divide 580 by 34 and show the answer '''here, on this page'''.\n\n\n;Related tasks:\n:*   Egyptian fractions\n\n\n;References:\n:*   Egyptian Number System\n\n", "solution": "using System;\nusing System.Collections;\n\nnamespace Egyptian_division\n{\n\tclass Program\n\t{\n\t\tpublic static void Main(string[] args)\n\t\t{\n\t\t\tConsole.Clear();\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.WriteLine(\" Egyptian division \");\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.Write(\" Enter value of dividend : \");\n\t\t\tint dividend = int.Parse(Console.ReadLine());\n\t\t\t     \n\t\t\tConsole.Write(\" Enter value of divisor : \");\n\t\t\tint divisor = int.Parse(Console.ReadLine());\n\t\t\t                         \n\t\t\tDivide(dividend, divisor);\n\t\t\t\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.Write(\"Press any key to continue . . . \");\n\t\t\tConsole.ReadKey(true);\n\t\t\t\n\t\t\t\n\t\t\t\n\t\t}\n\t\t\n\t\tstatic void Divide(int dividend, int divisor)\n\t\t{\n\t\t\t//\n\t\t\t// Local variable declaration and initialization\n\t\t\t//\n\t\t\tint result   = 0;\n\t\t\tint reminder = 0;\n\t\t\t\n\t\t\tint powers_of_two = 0;\n\t\t\tint doublings \t  = 0;\n\t\t\t\n\t\t\tint answer \t= 0;\n\t\t\tint accumulator = 0;\n\t\t\t\n\t\t\tint two = 2;\n\t\t\tint pow = 0;\n\t\t\tint row = 0;\n\t\t\t\n\t\t\t//\n\t\t\t// Tables declaration\n\t\t\t//\n\t\t\tArrayList table_powers_of_two = new ArrayList();\n\t\t\tArrayList table_doublings     = new ArrayList();\n\t\t\t\n\t\t\t//\n\t\t\t// Fill and Show table values\n\t\t\t//\n\t\t\tConsole.WriteLine(\"                           \");\n\t\t\tConsole.WriteLine(\" powers_of_2     doublings \");\n\t\t\tConsole.WriteLine(\"                           \");\n\t\t\t\n\t\t\t// Set initial values\n\t\t\tpowers_of_two = 1;\n\t\t\tdoublings = divisor;\n\t\t\twhile( doublings <= dividend )\n\t\t\t{\n\t\t\t\t// Set table value\n\t\t\t\ttable_powers_of_two.Add( powers_of_two );\n\t\t\t\ttable_doublings.Add( doublings );\n\t\t\t\t\n\t\t\t\t// Show new table row\n\t\t\t\tConsole.WriteLine(\"{0,8}{1,16}\",powers_of_two, doublings);\n\t\t\t\t\n\t\t\t\t\n\t\t\t\tpow++;\n\t\t\t\t\n\t\t\t\tpowers_of_two = (int)Math.Pow( two, pow );\n\t\t\t\tdoublings = powers_of_two * divisor;\n\t\t\t}\n\t\t\tConsole.WriteLine(\"                           \");\n\t\t\t\n\t\t\t//\n\t\t\t// Calculate division and Show table values\n\t\t\t//\n\t\t\trow = pow - 1;\n\t\t\tConsole.WriteLine(\"                                                 \");\n\t\t\tConsole.WriteLine(\" powers_of_2     doublings   answer   accumulator\");\n\t\t\tConsole.WriteLine(\"                                                 \");\n\t\t\tConsole.SetCursorPosition(Console.CursorLeft, Console.CursorTop + row);\n\t\t\t\n\t\t\tpow--;\n\t\t\twhile( pow >= 0 && accumulator < dividend )\n\t\t\t{\n\t\t\t\t// Get values from tables\n\t\t\t\tdoublings = int.Parse(table_doublings[pow].ToString());\n\t\t\t\tpowers_of_two = int.Parse(table_powers_of_two[pow].ToString());\n\t\t\t\t\n\t\t\t\tif(accumulator + int.Parse(table_doublings[pow].ToString()) <= dividend )\n\t\t\t\t{\n\t\t\t\t\t// Set new values\n\t\t\t\t\taccumulator += doublings;\n\t\t\t\t\tanswer += powers_of_two;\n\t\t\t\t\t\n\t\t\t\t\t// Show accumulated row values in different collor\n\t\t\t\t\tConsole.ForegroundColor = ConsoleColor.Green;\n\t\t\t\t\tConsole.Write(\"{0,8}{1,16}\",powers_of_two, doublings);\n\t\t\t\t\tConsole.ForegroundColor = ConsoleColor.Green;\n\t\t\t\t\tConsole.WriteLine(\"{0,10}{1,12}\", answer, accumulator);\n\t\t\t\t\tConsole.SetCursorPosition(Console.CursorLeft, Console.CursorTop - 2);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t// Show not accumulated row walues\n\t\t\t\t\tConsole.ForegroundColor = ConsoleColor.DarkGray;\n\t\t\t\t\tConsole.Write(\"{0,8}{1,16}\",powers_of_two, doublings);\n\t\t\t\t\tConsole.ForegroundColor = ConsoleColor.Gray;\n\t\t\t\t\tConsole.WriteLine(\"{0,10}{1,12}\", answer, accumulator);\n\t\t\t\t\tConsole.SetCursorPosition(Console.CursorLeft, Console.CursorTop - 2);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t\n\t\t\t\tpow--;\n\t\t\t}\n\t\t\t\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.SetCursorPosition(Console.CursorLeft, Console.CursorTop + row + 2);\n\t\t\tConsole.ResetColor();\n\t\t\t\n\t\t\t// Set result and reminder\n\t\t\tresult = answer;\n\t\t\tif( accumulator < dividend )\n\t\t\t{\n\t\t\t\treminder = dividend - accumulator;\n\t\t\t\t\n\t\t\t\tConsole.WriteLine(\" So \" + dividend +\n\t\t\t\t                  \" divided by \" + divisor +\n\t\t\t\t                  \" using the Egyptian method is \\n \" + result +\n\t\t\t\t                  \" remainder (\" + dividend + \" - \" + accumulator +\n\t\t\t\t                  \") or \" + reminder);\n\t\t\t\tConsole.WriteLine();\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\treminder = 0;\n\t\t\t\t\n\t\t\t\tConsole.WriteLine(\" So \" + dividend +\n\t\t\t\t                  \" divided by \" + divisor +\n\t\t\t\t                  \" using the Egyptian method is \\n \" + result +\n\t\t\t\t                  \" remainder \" + reminder);\n\t\t\t\tConsole.WriteLine();\n\t\t\t}\n\t\t}\n\t}\n}\n"}
{"title": "Elementary cellular automaton", "language": "C sharp|C#", "task": "An '''cellular automaton where there are two possible states (labeled 0 and 1) and the rule to determine the state of a cell in the next generation depends only on the current state of the cell and its two immediate neighbors.  Those three values can be encoded with three bits.\n\nThe rules of evolution are then encoded with eight bits indicating the outcome of each of the eight possibilities 111, 110, 101, 100, 011, 010, 001 and 000 in this order.  Thus for instance the rule 13 means that a state is updated to 1 only in the cases 011, 010 and 000, since 13 in binary is 0b00001101.\n\n\n;Task:\nCreate a subroutine, program or function that allows to create and visualize the evolution of any of the 256 possible elementary cellular automaton of arbitrary space length and for any given initial state.  You can demonstrate your solution with any automaton of your choice.\n\nThe space state should ''wrap'':  this means that the left-most cell should be considered as the right neighbor of the right-most cell, and reciprocally.\n\nThis task is basically a generalization of [[one-dimensional cellular automata]].\n\n\n;See also\n* Cellular automata (natureofcode.com)\n\n", "solution": "using System;\nusing System.Collections;\nnamespace ElementaryCellularAutomaton\n{\n    class Automata\n    {\n        BitArray cells, ncells;\n        const int MAX_CELLS = 19;\n\n        public void run()\n        {\n            cells = new BitArray(MAX_CELLS);\n            ncells = new BitArray(MAX_CELLS);\n            while (true)\n            {\n                Console.Clear();\n                Console.WriteLine(\"What Rule do you want to visualize\");\n                doRule(int.Parse(Console.ReadLine()));\n                Console.WriteLine(\"Press any key to continue...\");\n                Console.ReadKey();\n            }\n        }\n\n        private byte getCells(int index)\n        {\n            byte b;\n            int i1 = index - 1,\n                i2 = index,\n                i3 = index + 1;\n\n            if (i1 < 0) i1 = MAX_CELLS - 1;\n            if (i3 >= MAX_CELLS) i3 -= MAX_CELLS;\n\n            b = Convert.ToByte(\n                4 * Convert.ToByte(cells.Get(i1)) +\n                2 * Convert.ToByte(cells.Get(i2)) +\n                Convert.ToByte(cells.Get(i3)));\n            return b;\n        }\n\n        private string getBase2(int i)\n        {\n            string s = Convert.ToString(i, 2);\n            while (s.Length < 8)\n            { s = \"0\" + s; }\n            return s;\n        }\n\n        private void doRule(int rule)\n        {\n            Console.Clear();\n            string rl = getBase2(rule);\n            cells.SetAll(false);\n            ncells.SetAll(false);\n            cells.Set(MAX_CELLS / 2, true);\n\n            Console.WriteLine(\"Rule: \" + rule + \"\\n----------\\n\");\n\n            for (int gen = 0; gen < 51; gen++)\n            {\n                Console.Write(\"{0, 4}\", gen + \": \");\n\n                foreach (bool b in cells)\n                    Console.Write(b ? \"#\" : \".\");\n\n                Console.WriteLine(\"\");\n\n                int i = 0;\n                while (true)\n                {\n                    byte b = getCells(i);\n                    ncells[i] = '1' == rl[7 - b] ? true : false;\n                    if (++i == MAX_CELLS) break;\n                }\n\n                i = 0;\n                foreach (bool b in ncells)\n                    cells[i++] = b;\n            }\n            Console.WriteLine(\"\");\n        }\n\n    };\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            Automata t = new Automata();\n            t.run();\n        }\n    }\n}\n"}
{"title": "Empty directory", "language": "C sharp|C#", "task": "Starting with a path to some directory, determine whether the directory is empty.\n\nAn empty directory contains no files nor subdirectories. \nWith [[Unix]] or [[Windows]] systems, every directory contains an entry for \".\" and almost every directory contains \"..\" (except for a root directory); an empty directory contains no other entries.\n\n", "solution": "using System;\nusing System.IO;\n\nclass Program\n{\n    static void Main( string[] args )\n    {\n        foreach ( string dir in args )\n        {\n            Console.WriteLine( \"'{0}' {1} empty\", dir, IsDirectoryEmpty( dir ) ? \"is\" : \"is not\" );\n        }\n    }\n\n    private static bool IsDirectoryEmpty( string dir )\n    {\n        return ( Directory.GetFiles( dir ).Length == 0 &&\n            Directory.GetDirectories( dir ).Length == 0 );\n    }\n}\n"}
{"title": "Empty string", "language": "C sharp|C#", "task": "Languages may have features for dealing specifically with empty strings \n(those containing no characters).\n\n\n;Task:\n::*   Demonstrate how to assign an empty string to a variable.\n::*   Demonstrate how to check that a string is empty.\n::*   Demonstrate how to check that a string is not empty.\n\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nstatic class Program\n{\n    // In short:\n    public static void Foo()\n    {\n        string s;\n\n        // Assign empty string:\n        s = \"\";\n        // or\n        s = string.Empty;\n\n        // Check for empty string only (false if s is null):\n        if (s != null && s.Length == 0) { }\n\n        // Check for null or empty (more idiomatic in .NET):\n        if (string.IsNullOrEmpty(s)) { }\n    }\n\n    public static void Main()\n    {\n        // Equality is somewhat convoluted in .NET.\n        // The methods above are the author's recommendation for each case.\n\n        // s is initialized to null. It is a variable of the System.String type that is a null reference and is not\n        // the empty string.\n        string s = null;\n\n        // Alias Console.WriteLine(bool) with a shorter name to make the demonstration code less verbose.\n        Action<bool> P = Console.WriteLine;\n\n        // Assign the empty string literal to s.\n        s = \"\";\n\n        // ' Assign String.Empty to s.\n        s = string.Empty;\n\n        // The empty string literal is the same object reference as String.Empty because of string interning, meaning the\n        // behavior of the two is identical.\n        // From this point on, \"\" will be used instead of String.Empty for brevity.\n\n        //#== operator (object)\n        // The == operator tests for reference equality when overload resolution fails to find an operator defined by\n        // either operand type. However, which strings are interned is a CLR implementation detail and may be unreliable\n        // when comparing non-empty strings. The equivalent in VB.NET would be s Is \"\".\n        // Note that there is no such operator as Object.op_Equality(Object, Object): the use of the == operator for\n        // types of type Object is a C# language feature.\n        P((object)s == \"\");\n\n        //#Object.ReferenceEquals(Object, Object)\n        // The previous line is semantically to the following, though it does not involve a method call. \n        P(object.ReferenceEquals(s, \"\"));\n\n        //#String.op_Equality(String, String)\n        // The equality operator of System.String is implemented as a call to String.Equals(String). Operators cannot be\n        // called with method syntax in C#.\n        P(s == \"\");\n\n        //#String.Equals(String, String)\n        // Call the static method defined on the String type, which first calls Object.ReferenceEquals and then, after\n        // verifying that both are strings of the same length, compares the strings character-by-character.\n        P(string.Equals(s, \"\"));\n\n        //#Object.Equals(Object, Object)\n        // First checks for reference equality and whether one or both of the arguments is null. It then invokes the\n        // instance Equals method of the left parameter.\n        P(object.Equals(s, \"\"));\n\n        //#String.Equals(String)\n        // The method is called with the string literal as the receiver because a NullReferenceException is thrown if s\n        // is null.\n        P(\"\".Equals(s));\n\n        //#String.Length\n        // Check the Length property. The ?. (null-conditional) operator is used to avoid NullReferenceException. The Equals\n        // call above can also be done this way. Null propagation makes the equality operator return false if one operand\n        // is a Nullable<T> and does not have a value, making this result in false when s is null.\n        P(s?.Length == 0);\n\n        //#String.Length\n        // A more traditional version of the null-conditional using a guard clause.\n        // Both the null-conditional and this are noticeably (~4 times) faster than \"\".Equals(s). In general, it appears that\n        // for empty strings, using the length is faster than using an equality comparison.\n        P(s != null && s.Length == 0);\n\n        //#String.IsNullOrEmpty(String)\n        // Note that all of the other methods give false for null.\n        // A static method of System.String that returns true if the string is null or its length is zero.\n        P(string.IsNullOrEmpty(s));\n\n        //#System.Collections.Generic.EqualityComparer(Of String).Default.Equals(String, String)\n        // The EqualityComparer(Of T) class provides default implementations when an IEqualityComparer(Of T) is required.\n        // The implementation for String calls String.Equals(String).\n        P(EqualityComparer<string>.Default.Equals(s, \"\"));\n\n        Console.WriteLine();\n\n        // Each of the means described above, except testing for a non-empty string.\n        P((object)s != \"\");\n        P(!object.ReferenceEquals(s, \"\"));\n        P(s != \"\");\n        P(!string.Equals(s, \"\"));\n        P(!object.Equals(s, \"\"));\n        P(!\"\".Equals(s));\n        P(s?.Length != 0); // Still false when s is null!\n        P(s == null || s.Length != 0);\n        P(!string.IsNullOrEmpty(s));\n        P(!EqualityComparer<string>.Default.Equals(s, \"\"));\n    }\n}"}
{"title": "Equilibrium index", "language": "C sharp|C#", "task": "An equilibrium index of a sequence is an index into the sequence such that the sum of elements at lower indices is equal to the sum of elements at higher indices. \n\n\nFor example, in a sequence   A:\n\n:::::   A_0 = -7\n:::::   A_1 =  1\n:::::   A_2 =  5\n:::::   A_3 =  2\n:::::   A_4 = -4\n:::::   A_5 =  3\n:::::   A_6 =  0\n\n3   is an equilibrium index, because:\n\n:::::   A_0 + A_1 + A_2 = A_4 + A_5 + A_6\n\n6   is also an equilibrium index, because:\n\n:::::   A_0 + A_1 + A_2 + A_3 + A_4 + A_5 = 0\n\n(sum of zero elements is zero) \n\n7   is not an equilibrium index, because it is not a valid index of sequence A.\n\n\n;Task;\nWrite a function that, given a sequence, returns its equilibrium indices (if any).\n\nAssume that the sequence may be very long.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nclass Program\n{\n    static IEnumerable<int> EquilibriumIndices(IEnumerable<int> sequence)\n    {\n        var left = 0;\n        var right = sequence.Sum();\n        var index = 0;\n        foreach (var element in sequence)\n        {\n            right -= element;\n            if (left == right)\n            {\n                yield return index;\n            }\n            left += element;\n            index++;\n        }\n    }\n\n    static void Main()\n    {\n        foreach (var index in EquilibriumIndices(new[] { -7, 1, 5, 2, -4, 3, 0 }))\n        {\n            Console.WriteLine(index);\n        }\n    }\n}"}
{"title": "Euler's identity", "language": "C sharp|C#", "task": "{{Wikipedia|Euler's_identity}}\n\n\nIn mathematics, ''Euler's identity'' is the equality:\n\n                ei\\pi + 1 = 0\n\nwhere\n\n    e is Euler's number, the base of natural logarithms,\n    ''i'' is the imaginary unit, which satisfies ''i''2 = -1, and\n    \\pi is pi, the ratio of the circumference of a circle to its diameter.\n\nEuler's identity is often cited as an example of deep mathematical beauty. Three of the basic arithmetic operations occur exactly once each: addition, multiplication, and exponentiation. The identity also links five fundamental mathematical constants:\n\n    The number 0.\n    The number 1.\n    The number \\pi (\\pi = 3.14159+),\n    The number e (e = 2.71828+), which occurs widely in mathematical analysis.\n    The number ''i'', the imaginary unit of the complex numbers.\n\n;Task\nShow in your language that Euler's identity is true. As much as possible and practical, mimic the Euler's identity equation. \n\nMost languages are limited to IEEE 754 floating point calculations so will have some error in the calculation. \n\nIf that is the case, or there is some other limitation, show \nthat ei\\pi + 1 is ''approximately'' equal to zero and \nshow the amount of error in the calculation.\n\nIf your language is capable of symbolic calculations, show \nthat ei\\pi + 1 is ''exactly'' equal to zero for bonus kudos points.\n\n", "solution": "using System;\nusing System.Numerics;\n\npublic class Program\n{\n    static void Main() {\n        Complex e = Math.E;\n        Complex i = Complex.ImaginaryOne;\n        Complex \u03c0 = Math.PI;\n        Console.WriteLine(Complex.Pow(e, i * \u03c0) + 1);\n    }\n}"}
{"title": "Euler's sum of powers conjecture", "language": "C sharp|C# from Java", "task": "There is a conjecture in mathematics that held for over two hundred years before it was disproved by the finding of a counterexample in 1966 by Lander and Parkin.\n\nThis conjecture is called Euler's sum of powers conjecture and can be stated as such:\n\n:At least k positive kth powers are required to sum to a kth power, except for the trivial case of one kth power: yk = yk.\n\nIn 1966, Leon J. Lander and Thomas R. Parkin used a brute-force search on a CDC 6600 computer restricting numbers to those less than 250.\n\nThe task consists in writing a program to search for an integer solution of x_0^5 + x_1^5 + x_2^5 + x_3^5 = y^5 where all x_i and y are distinct integers between 0 and 250 (exclusive). Show an answer here.\n\nRelated tasks are:\n* [[Pythagorean quadruples]]. \n* [[Pythagorean triples]].\n\n\n\n", "solution": "using System;\n\nnamespace EulerSumOfPowers {\n    class Program {\n        const int MAX_NUMBER = 250;\n\n        static void Main(string[] args) {\n            bool found = false;\n            long[] fifth = new long[MAX_NUMBER];\n\n            for (int i = 1; i <= MAX_NUMBER; i++) {\n                long i2 = i * i;\n                fifth[i - 1] = i2 * i2 * i;\n            }\n\n            for (int a = 0; a < MAX_NUMBER && !found; a++) {\n                for (int b = a; b < MAX_NUMBER && !found; b++) {\n                    for (int c = b; c < MAX_NUMBER && !found; c++) {\n                        for (int d = c; d < MAX_NUMBER && !found; d++) {\n                            long sum = fifth[a] + fifth[b] + fifth[c] + fifth[d];\n                            int e = Array.BinarySearch(fifth, sum);\n                            found = e >= 0;\n                            if (found) {\n                                Console.WriteLine(\"{0}^5 + {1}^5 + {2}^5 + {3}^5 = {4}^5\", a + 1, b + 1, c + 1, d + 1, e + 1);\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n}"}
{"title": "Euler's sum of powers conjecture", "language": "C sharp|C# from vbnet", "task": "There is a conjecture in mathematics that held for over two hundred years before it was disproved by the finding of a counterexample in 1966 by Lander and Parkin.\n\nThis conjecture is called Euler's sum of powers conjecture and can be stated as such:\n\n:At least k positive kth powers are required to sum to a kth power, except for the trivial case of one kth power: yk = yk.\n\nIn 1966, Leon J. Lander and Thomas R. Parkin used a brute-force search on a CDC 6600 computer restricting numbers to those less than 250.\n\nThe task consists in writing a program to search for an integer solution of x_0^5 + x_1^5 + x_2^5 + x_3^5 = y^5 where all x_i and y are distinct integers between 0 and 250 (exclusive). Show an answer here.\n\nRelated tasks are:\n* [[Pythagorean quadruples]]. \n* [[Pythagorean triples]].\n\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\n\nnamespace Euler_cs\n{\n    class Program\n    {\n        struct Pair\n        {\n            public int a, b;\n            public Pair(int x, int y)\n            {\n                a = x; b = y;\n            }\n        }\n\n        static int min = 1, max = 250;\n        static ulong[] p5;\n        static SortedDictionary<ulong, Pair>[] sum2 =\n                   new SortedDictionary<ulong, Pair>[30];\n\n        static string Fmt(Pair p)\n        {\n            return string.Format(\"{0}^5 + {1}^5\", p.a, p.b);\n        }\n\n        public static void InitM()\n        {\n            for (int i = 0; i <= 29; i++)\n                sum2[i] = new SortedDictionary<ulong, Pair>();\n            p5 = new ulong[max + 1];\n            p5[min] = Convert.ToUInt64(min) * Convert.ToUInt64(min);\n            p5[min] *= p5[min] * Convert.ToUInt64(min);\n            for (int i = min; i <= max - 1; i++)\n            {\n                for (int j = i + 1; j <= max; j++)\n                {\n                    p5[j] = Convert.ToUInt64(j) * Convert.ToUInt64(j);\n                    p5[j] *= p5[j] * Convert.ToUInt64(j);\n                    if (j == max) continue;\n                    ulong x = p5[i] + p5[j];\n                    sum2[x % 30].Add(x, new Pair(i, j));\n                }\n            }\n        }\n\n        static List<string> CalcM(int m)\n        {\n            List<string> res = new List<string>();\n            for (int i = max; i >= min; i--)\n            {\n                ulong p = p5[i]; int pm = i % 30, mp = (pm - m + 30) % 30;\n                foreach (var s in sum2[m].Keys)\n                {\n                    if (p <= s) break;\n                    ulong t = p - s;\n                    if (sum2[mp].Keys.Contains(t) && sum2[mp][t].a > sum2[m][s].b)\n                        res.Add(string.Format(\"  {1} + {2} = {0}^5\",\n                            i, Fmt(sum2[m][s]), Fmt(sum2[mp][t])));\n                }\n            }\n            return res;\n        }\n\n        static int Snip(string s)\n        {\n            int p = s.IndexOf(\"=\") + 1;\n            return Convert.ToInt32(s.Substring(p, s.IndexOf(\"^\", p) - p));\n        }\n\n        static int CompareRes(string x, string y)\n        {\n            int res = Snip(x).CompareTo(Snip(y));\n            if (res == 0) res = x.CompareTo(y);\n            return res;\n        }\n\n        static int Validify(int def, string s)\n        {\n            int res = def, t = 0; int.TryParse(s, out t);\n            if (t >= 1 && t < Math.Pow((double)(ulong.MaxValue >> 1), 0.2))\n                res = t;\n            return res;\n        }\n\n        static void Switch(ref int a, ref int b)\n        {\n            int t = a; a = b; b = t;\n        }\n\n        static void Main(string[] args)\n        {\n            if (args.Count() > 1)\n            {\n                min = Validify(min, args[0]);\n                max = Validify(max, args[1]);\n                if (max < min) Switch(ref max, ref min);\n            }\n            else if (args.Count() == 1)\n                max = Validify(max, args[0]);\n            Console.WriteLine(\"Mod 30 shortcut with threading, checking from {0} to {1}...\", min, max);\n            List<string> res = new List<string>();\n            DateTime st = DateTime.Now;\n            List<Task<List<string>>> taskList = new List<Task<List<string>>>();\n            InitM();\n            for (int j = 0; j <= 29; j++)\n            {\n                var jj = j;\n                taskList.Add(Task.Run(() => CalcM(jj)));\n            }\n            Task.WhenAll(taskList);\n            foreach (var item in taskList.Select(t => t.Result))\n                res.AddRange(item);\n            res.Sort(CompareRes);\n            foreach (var item in res)\n                Console.WriteLine(item);\n            Console.WriteLine(\"  Computation time to check entire space was {0} seconds\",\n                (DateTime.Now - st).TotalSeconds);\n            if (System.Diagnostics.Debugger.IsAttached)\n                Console.ReadKey();\n        }\n    }\n}"}
{"title": "Even or odd", "language": "C sharp|C#", "task": "Test whether an integer is even or odd.\n\nThere is more than one way to solve this task:\n\n* Use the even and odd predicates, if the language provides them.\n* Check the least significant digit. With binary integers, ''i iff ''i'' is even, or equals 1 iff ''i'' is odd.\n* Divide ''i'' by 2. The remainder equals 0 iff ''i'' is even. The remainder equals +1 or -1 iff ''i'' is odd.\n* Use modular congruences:\n** ''i''  0 (mod 2) iff ''i'' is even.\n** ''i''  1 (mod 2) iff ''i'' is odd.\n\n", "solution": "namespace RosettaCode\n{\n    using System;\n\n    public static class EvenOrOdd\n    {\n        public static bool IsEvenBitwise(this int number)\n        {\n            return (number & 1) == 0;\n        }\n\n        public static bool IsOddBitwise(this int number)\n        {\n            return (number & 1) != 0;\n        }\n\n        public static bool IsEvenRemainder(this int number)\n        {\n            int remainder;\n            Math.DivRem(number, 2, out remainder);\n            return remainder == 0;\n        }\n\n        public static bool IsOddRemainder(this int number)\n        {\n            int remainder;\n            Math.DivRem(number, 2, out remainder);\n            return remainder != 0;\n        }\n\n        public static bool IsEvenModulo(this int number)\n        {\n            return (number % 2) == 0;\n        }\n\n        public static bool IsOddModulo(this int number)\n        {\n            return (number % 2) != 0;\n        }\n    }\n    public class Program\n    {\n        public static void Main()\n        {\n            int num = 26;               //Set this to any integer.\n            if (num.IsEvenBitwise())    //Replace this with any even function.\n            {\n                Console.Write(\"Even\");\n            }\n            else\n            {\n                Console.Write(\"Odd\");\n            }\n            //Prints \"Even\".\n            if (num.IsOddBitwise())    //Replace this with any odd function.\n            {\n                Console.Write(\"Odd\");\n            }\n            else\n            {\n                Console.Write(\"Even\");\n            }\n            //Prints \"Even\".\n        }\n    }\n}"}
{"title": "Evolutionary algorithm", "language": "C sharp", "task": "Starting with:\n* The target string: \"METHINKS IT IS LIKE A WEASEL\".\n* An array of random characters chosen from the set of upper-case letters together with the space, and of the same length as the target string. (Call it the parent).\n* A fitness function that computes the 'closeness' of its argument to the target string.\n* A mutate function that given a string and a mutation rate returns a copy of the string, with some characters probably mutated.\n* While the parent is not yet the target:\n:* copy the parent C times, each time allowing some random probability that another character might be substituted using mutate.\n:* Assess the fitness of the parent and all the copies to the target and make the most fit string the new parent, discarding the others.\n:* repeat until the parent converges, (hopefully), to the target.\n\n\n;See also:\n*   Wikipedia entry:   Weasel algorithm.\n*   Wikipedia entry:   Evolutionary algorithm.\n\n\nNote: to aid comparison, try and ensure the variables and functions mentioned in the task description appear in solutions\n\nA cursory examination of a few of the solutions reveals that the instructions have not been followed rigorously in some solutions. Specifically,\n* While the parent is not yet the target:\n:* copy the parent C times, each time allowing some random probability that another character might be substituted using mutate.\n\nNote that some of the the solutions given retain characters in the mutated string that are ''correct'' in the target string. However, the instruction above does not state to retain any of the characters while performing the mutation. Although some may believe to do so is implied from the use of \"converges\"\n\n (:* repeat until the parent converges, (hopefully), to the target.\n\nStrictly speaking, the new parent should be selected from the new pool of mutations, and then the new parent used to generate the next set of mutations with parent characters getting retained only by ''not'' being mutated. It then becomes possible that the new set of mutations has no member that is fitter than the parent!\n\nAs illustration of this error, the code for 8th has the following remark.\n\n Create a new string based on the TOS, '''changing randomly any characters which\n don't already match the target''':\n\n''NOTE:'' this has been changed, the 8th version is completely random now\n\nClearly, this algo will be applying the mutation function only to the parent characters that don't match to the target characters!\n\nTo ensure that the new parent is never less fit than the prior parent, both the parent and all of the latest mutations are subjected to the fitness test to select the next parent.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nstatic class Program {\n    static Random Rng = new Random((int)DateTime.Now.Ticks);\n\n    static char NextCharacter(this Random self) {\n        const string AllowedChars = \" ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n        return AllowedChars[self.Next() % AllowedChars.Length];\n    }\n\n    static string NextString(this Random self, int length) {\n        return String.Join(\"\", Enumerable.Repeat(' ', length)\n            .Select(c => Rng.NextCharacter()));\n    }\n\n    static int Fitness(string target, string current) {\n        return target.Zip(current, (a, b) => a == b ? 1 : 0).Sum();\n    }\n\n    static string Mutate(string current, double rate) {\n        return String.Join(\"\", from c in current\n               select Rng.NextDouble() <= rate ? Rng.NextCharacter() : c);\n    }\n\n    static void Main(string[] args) {\n        const string target = \"METHINKS IT IS LIKE A WEASEL\";\n        const int C = 100;\n        const double P = 0.05;\n\n        // Start with a random string the same length as the target.\n        string parent = Rng.NextString(target.Length);\n\n        Console.WriteLine(\"START:       {0,20} fitness: {1}\", \n            parent, Fitness(target, parent));\n        int i = 0;\n\n        while (parent != target) {\n            // Create C mutated strings + the current parent.\n            var candidates = Enumerable.Range(0, C + 1)\n                .Select(n => n > 0 ? Mutate(parent, P) : parent);\n\n            // select the fittest\n            parent = candidates.OrderByDescending(c => Fitness(target, c)).First();\n\n            ++i;\n            Console.WriteLine(\"     #{0,6} {1,20} fitness: {2}\", \n                i, parent, Fitness(target, parent));\n        }\n\n        Console.WriteLine(\"END: #{0,6} {1,20}\", i, parent);\n    }\n}"}
{"title": "Execute HQ9+", "language": "C sharp|C#", "task": "Implement a   ''' [[HQ9+]] '''   interpreter or compiler.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nclass Program\n{\n    static void RunCode(string code)\n    {\n        int accumulator = 0;\n        var opcodes = new Dictionary<char, Action>\n        {\n            {'H', () => Console.WriteLine(\"Hello, World!\"))},\n            {'Q', () => Console.WriteLine(code) },\n            {'9', () => Console.WriteLine(Enumerable.Range(1,100).Reverse().Select(n => string.Format(\"{0} bottles of beer on the wall\\n{0} bottles of beer\\nTake one down, pass it around\\n{1} bottles of beer on the wall\\n\", n, n-1)).Aggregate((a,b) => a + \"\\n\" + b))},\n            {'+', () => accumulator++ }\n        }\n\n        foreach(var c in code)\n            opcodes[c]();\n    }\n}\n"}
{"title": "Exponentiation order", "language": "C sharp|C#", "task": "This task will demonstrate the order of exponentiation   ('''xy''')    when there are multiple exponents.\n\n(Many programming languages,   especially those with extended-precision integer arithmetic,   usually support one of  **, ^, |  or some such for exponentiation.)\n\n\n;Task requirements\nShow the result of a language's evaluation of multiple exponentiation (either as an integer or floating point).\n\nIf your language's exponentiation operator is not one of the usual ones, please comment on how to recognize it.\n\n\nUsing whatever operator or syntax your language supports (if any), show the results in three lines (with identification):\n  \n::::*   5**3**2 \n::::*   (5**3)**2\n::::*   5**(3**2)\n\n\nIf there are other methods (or formats) of multiple exponentiations, show them as well. \n\n\n;See also:\n* MathWorld entry:   exponentiation\n\n\n;Related tasks:\n*   exponentiation operator\n*   arbitrary-precision integers (included)\n*   [[Exponentiation with infix operators in (or operating on) the base]]\n\n", "solution": "using System;\n\nnamespace exponents\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            /* \n             * Like C, C# does not have an exponent operator.\n             * Exponentiation is done via Math.Pow, which\n             * only takes two arguments \n             */\n            Console.WriteLine(Math.Pow(Math.Pow(5, 3), 2));\n            Console.WriteLine(Math.Pow(5, Math.Pow(3, 2)));\n            Console.Read();\n        }\n\n    }\n}\n"}
{"title": "Extend your language", "language": "C sharp|C#", "task": "{{Control Structures}}Some programming languages allow you to extend the language. While this can be done to a certain degree in most languages (e.g. by using macros), other languages go much further. Most notably in the Forth and Lisp families, programming per se is done by extending the language without any formal distinction between built-in and user-defined elements.\n\nIf your language supports it, show how to introduce a new flow control mechanism. A practical and useful example is a four-way branch:\n\nOccasionally, code must be written that depends on ''two'' conditions, resulting in up to four branches (depending on whether both, only the first, only the second, or none of the conditions are \"true\"). In a C-like language this could look like the following:\n\n   if (condition1isTrue) {\n      if (condition2isTrue)\n         bothConditionsAreTrue();\n      else\n         firstConditionIsTrue();\n   }\n   else if (condition2isTrue)\n      secondConditionIsTrue();\n   else\n      noConditionIsTrue();\n\nBesides being rather cluttered, the statement(s) for 'condition2isTrue' must be written down twice. If 'condition2isTrue' were a lengthy and involved expression, it would be quite unreadable, and the code generated by the compiler might be unnecessarily large.\n\nThis can be improved by introducing a new keyword '''if2'''. It is similar to '''if''', but takes two conditional statements instead of one, and up to three 'else' statements. One proposal (in pseudo-C syntax) might be:\n\n   if2 (condition1isTrue) (condition2isTrue)\n      bothConditionsAreTrue();\n   else1\n      firstConditionIsTrue();\n   else2\n      secondConditionIsTrue();\n   else\n      noConditionIsTrue();\n\nPick the syntax which suits your language. The keywords 'else1' and 'else2' are just examples. The new conditional expression should look, nest and behave analogously to the language's built-in 'if' statement.\n", "solution": "using System;\nusing System.Reflection;\n\nnamespace Extend_your_language\n{\n\t\n\n\tclass Program\n\t{\n\t\t\n\t\tpublic static void Main(string[] args)\n\t\t{\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.WriteLine(\"Hello World!\");\n\t\t\tConsole.WriteLine();\n\t\t\t\n\t\t\tint x = 0;\n\t\t\tint y = 0;\n\t\t\t\n\t\t\tfor(x=0;x<2;x++)\n\t\t\t{\n\t\t\t\tfor(y=0;y<2;y++)\n\t\t\t\t{\n\t\t\t\t\t\n\t\t\t\t\tCONDITIONS( (x==0) , (y==0) ).\n\t\t\t\t\t\tIF2  (\"METHOD1\").\n\t\t\t\t\t\tELSE1(\"METHOD2\").\n\t\t\t\t\t\tELSE2(\"METHOD3\").\n\t\t\t\t\t\tELSE (\"METHOD4\");\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.Write(\"Press any key to continue . . . \");\n\t\t\tConsole.ReadKey(true);\n\t\t}\n\t\t\n\t\t\n\t\t\n\t\t\n\t\tpublic static void METHOD1()\n\t\t{\n\t\t\tConsole.WriteLine(\"METHOD 1 executed - both are true\");\n\t\t}\n\t\t\n\t\tpublic static void METHOD2()\n\t\t{\n\t\t\tConsole.WriteLine(\"METHOD 2 executed - first is true\");\n\t\t}\n\t\t\n\t\tpublic static void METHOD3()\n\t\t{\n\t\t\tConsole.WriteLine(\"METHOD 3 executed - second is true\");\n\t\t}\n\t\t\n\t\tpublic static void METHOD4()\n\t\t{\n\t\t\tConsole.WriteLine(\"METHOD 4 executed - both are false\");\n\t\t}\n\t\t\n\t\t\n\t\tstatic int CONDITIONS(bool condition1, bool condition2)\n\t\t{\n\t\t\tint c = 0;\n\t\t\tif(condition1 && condition2)\n\t\t\t\tc = 0;\n\t\t\telse if(condition1)\n\t\t\t\tc = 1;\n\t\t\telse if(condition2)\n\t\t\t\tc = 2;\n\t\t\telse\n\t\t\t\tc = 3;\n\t\t\t\n\t\t\treturn c;\n\t\t}\n\t}\n\t\n\t\n\tpublic static class ExtensionMethods\n\t{\n\n\t\tpublic static int IF2(this int value, string method)\n\t\t{\n\t\t\tif(value == 0)\n\t\t\t{\n\t\t\t\tMethodInfo m = typeof(Program).GetMethod(method);\n\t\t\t\tm.Invoke(null,null);\n\t\t\t}\n\t\t\t\n\t\t\treturn value;\n\t\t}\n\t\t\n\t\tpublic static int ELSE1(this int value, string method)\n\t\t{\n\t\t\tif(value == 1)\n\t\t\t{\n\t\t\t\tMethodInfo m = typeof(Program).GetMethod(method);\n\t\t\t\tm.Invoke(null,null);\n\t\t\t}\n\t\t\t\n\t\t\treturn value;\n\t\t}\n\t\t\n\t\tpublic static int ELSE2(this int value, string method)\n\t\t{\n\t\t\tif(value == 2)\n\t\t\t{\n\t\t\t\tMethodInfo m = typeof(Program).GetMethod(method);\n\t\t\t\tm.Invoke(null,null);\n\t\t\t}\n\t\t\t\n\t\t\treturn value;\n\t\t}\n\t\t\n\t\tpublic static void ELSE(this int value, string method)\n\t\t{\n\t\t\tif(value == 3)\n\t\t\t{\n\t\t\t\tMethodInfo m = typeof(Program).GetMethod(method);\n\t\t\t\tm.Invoke(null,null);\n\t\t\t}\n\t\t}\n\t\t\n\t}\n}\n\n"}
{"title": "FASTA format", "language": "C sharp|C#", "task": "In FASTA.  \n\nA FASTA file can contain several strings, each identified by a name marked by a > (greater than) character at the beginning of the line.\n\n\n;Task:\nWrite a program that reads a FASTA file such as:\n\n>Rosetta_Example_1\nTHERECANBENOSPACE\n>Rosetta_Example_2\nTHERECANBESEVERAL\nLINESBUTTHEYALLMUST\nBECONCATENATED\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.IO;\nusing System.Text;\n\nclass Program\n{\n    public class FastaEntry\n    {\n        public string Name { get; set; }\n        public StringBuilder Sequence { get; set; }\n    }\n\n    static IEnumerable<FastaEntry> ParseFasta(StreamReader fastaFile)\n    {\n        FastaEntry f = null;\n        string line;\n        while ((line = fastaFile.ReadLine()) != null)\n        {\n            // ignore comment lines\n            if (line.StartsWith(\";\"))\n                continue;\n\n            if (line.StartsWith(\">\"))\n            {\n                if (f != null)\n                    yield return f;\n                f = new FastaEntry { Name = line.Substring(1), Sequence = new StringBuilder() };\n            }\n            else if (f != null)\n                f.Sequence.Append(line);\n        }\n        yield return f;\n    }\n\n    static void Main(string[] args)\n    {\n        try\n        {\n            using (var fastaFile = new StreamReader(\"fasta.txt\"))\n            {\n                foreach (FastaEntry f in ParseFasta(fastaFile))\n                    Console.WriteLine(\"{0}: {1}\", f.Name, f.Sequence);\n            }\n        }\n        catch (FileNotFoundException e)\n        {\n            Console.WriteLine(e);\n        }\n        Console.ReadLine();\n    }\n}"}
{"title": "Farey sequence", "language": "C sharp|C# from Java", "task": "The   Farey sequence   ''' ''F''n'''   of order   '''n'''   is the sequence of completely reduced fractions between   '''0'''   and   '''1'''   which, when in lowest terms, have denominators less than or equal to   '''n''',   arranged in order of increasing size.\n\nThe   ''Farey sequence''   is sometimes incorrectly called a   ''Farey series''. \n\n\nEach Farey sequence:\n:::*   starts with the value   '''0'''   (zero),   denoted by the fraction      \\frac{0}{1} \n:::*   ends with the value   '''1'''   (unity),   denoted by the fraction    \\frac{1}{1}.\n\n\nThe Farey sequences of orders   '''1'''   to   '''5'''   are:\n\n:::: {\\bf\\it{F}}_1 = \\frac{0}{1}, \\frac{1}{1}\n:\n:::: {\\bf\\it{F}}_2 = \\frac{0}{1}, \\frac{1}{2}, \\frac{1}{1}\n:\n:::: {\\bf\\it{F}}_3 = \\frac{0}{1}, \\frac{1}{3}, \\frac{1}{2}, \\frac{2}{3}, \\frac{1}{1}\n:\n:::: {\\bf\\it{F}}_4 = \\frac{0}{1}, \\frac{1}{4}, \\frac{1}{3}, \\frac{1}{2}, \\frac{2}{3}, \\frac{3}{4}, \\frac{1}{1}\n:\n:::: {\\bf\\it{F}}_5 = \\frac{0}{1}, \\frac{1}{5}, \\frac{1}{4}, \\frac{1}{3}, \\frac{2}{5}, \\frac{1}{2}, \\frac{3}{5}, \\frac{2}{3}, \\frac{3}{4}, \\frac{4}{5}, \\frac{1}{1}\n\n;Task\n*   Compute and show the Farey sequence for orders   '''1'''   through   '''11'''   (inclusive).\n*   Compute and display the   ''number''   of fractions in the Farey sequence for order   '''100'''   through   '''1,000'''   (inclusive)   by hundreds.\n*   Show the fractions as    '''n/d'''    (using the solidus [or slash] to separate the numerator from the denominator).   \n\n\nThe length   (the number of fractions)   of a Farey sequence asymptotically approaches:\n\n:::::::::::  3 x n2   /   \\pi2 \n\n;See also:\n*    OEIS sequence           A006842 numerators of Farey series of order 1, 2, *** \n*    OEIS sequence           A006843 denominators of Farey series of order 1, 2, *** \n*    OEIS sequence           A005728 number of fractions in Farey series of order n \n*   MathWorld entry          Farey sequence\n*   Wikipedia   entry   Farey sequence\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic static class FareySequence\n{\n    public static void Main() {\n        for (int i = 1; i <= 11; i++) {\n            Console.WriteLine($\"F{i}: \" + string.Join(\", \", Generate(i).Select(f => $\"{f.num}/{f.den}\")));\n        }\n        for (int i = 100; i <= 1000; i+=100) {\n            Console.WriteLine($\"F{i} has {Generate(i).Count()} terms.\");\n        }\n    }\n\n    public static IEnumerable<(int num, int den)> Generate(int i) {\n        var comparer = Comparer<(int n, int d)>.Create((a, b) => (a.n * b.d).CompareTo(a.d * b.n));\n        var seq = new SortedSet<(int n, int d)>(comparer);\n        for (int d = 1; d <= i; d++) {\n            for (int n = 0; n <= d; n++) {\n                seq.Add((n, d));\n            }\n        }\n        return seq;\n    }\n}"}
{"title": "Fast Fourier transform", "language": "C sharp|C#", "task": "Calculate the   FFT   (Fast Fourier Transform)   of an input sequence.\n\nThe most general case allows for complex numbers at the input \nand results in a sequence of equal length, again of complex numbers. \nIf you need to restrict yourself to real numbers, the output should \nbe the magnitude   (i.e.:   sqrt(re2 + im2))   of the complex result. \n\nThe classic version is the recursive Cooley-Tukey FFT. Wikipedia has pseudo-code for that. \nFurther optimizations are possible but not required.\n\n", "solution": "using System;\nusing System.Numerics;\nusing System.Linq;\nusing System.Diagnostics;\n\n// Fast Fourier Transform in C#\npublic class Program {\n\n    /* Performs a Bit Reversal Algorithm on a postive integer \n     * for given number of bits\n     * e.g. 011 with 3 bits is reversed to 110 */\n    public static int BitReverse(int n, int bits) {\n       int reversedN = n;\n       int count = bits - 1;\n\n       n >>= 1;\n       while (n > 0) {\n            reversedN = (reversedN << 1) | (n & 1);\n            count--;\n            n >>= 1;\n        }\n\n        return ((reversedN << count) & ((1 << bits) - 1));\n    }\n\n    /* Uses Cooley-Tukey iterative in-place algorithm with radix-2 DIT case\n     * assumes no of points provided are a power of 2 */\n    public static void FFT(Complex[] buffer) {\n#if false\n        int bits = (int)Math.Log(buffer.Length, 2);\n        for (int j = 1; j < buffer.Length / 2; j++) {\n\n            int swapPos = BitReverse(j, bits);\n            var temp = buffer[j];\n            buffer[j] = buffer[swapPos];\n            buffer[swapPos] = temp;\n        }\n// Said Zandian\n// The above section of the code is incorrect and does not work correctly and has two bugs.\n// BUG 1\n// The bug is that when you reach and index that was swapped previously it does swap it again\n// Ex. binary value n = 0010 and Bits = 4 as input to BitReverse routine and  returns 4. The code section above //     swaps it. Cells 2 and 4 are swapped. just fine.\n//     now binary value n = 0010 and Bits = 4 as input to BitReverse routine and returns 2. The code Section\n//     swap it. Cells 4 and 2 are swapped.     WROOOOONG\n// \n// Bug 2\n// The code works on the half section of the cells. In the case of Bits = 4 it means that we are having 16 cells\n// The code works on half the cells        for (int j = 1; j < buffer.Length / 2; j++) buffer.Length returns 16\n// and divide by 2 makes 8, so j goes from 1 to 7. This covers almost everything but what happened to 1011 value\n// which must be swap with 1101. and this is the second bug.\n// \n// use the following corrected section of the code. I have seen this bug in other languages that uses bit\n// reversal routine. \n\n#else\n            for (int j = 1; j < buffer.Length; j++)\n            {\n                int swapPos = BitReverse(j, bits);\n                if (swapPos <= j)\n                {\n                    continue;\n                }\n                var temp = buffer[j];\n                buffer[j] = buffer[swapPos];\n                buffer[swapPos] = temp;\n            }\n\n// First the full length is used and 1011 value is swapped with 1101. Second if new swapPos is less than j\n// then it means that swap was happen when j was the swapPos.\n\n#endif\n\n        for (int N = 2; N <= buffer.Length; N <<= 1) {\n            for (int i = 0; i < buffer.Length; i += N) {\n                for (int k = 0; k < N / 2; k++) {\n\n                    int evenIndex = i + k;\n                    int oddIndex = i + k + (N / 2);\n                    var even = buffer[evenIndex];\n                    var odd = buffer[oddIndex];\n\n                    double term = -2 * Math.PI * k / (double)N;\n                    Complex exp = new Complex(Math.Cos(term), Math.Sin(term)) * odd;\n\n                    buffer[evenIndex] = even + exp;\n                    buffer[oddIndex] = even - exp;\n\n                }\n            }\n        }\n    }\n\n    public static void Main(string[] args) {\n        Complex[] input = {1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0};       \n        \n        FFT(input);       \n                  \n        Console.WriteLine(\"Results:\");\n        foreach (Complex c in input) {\n            Console.WriteLine(c);   \n        }   \n    }\n}"}
{"title": "Feigenbaum constant calculation", "language": "C sharp|C# from Kotlin", "task": "Calculate the Feigenbaum constant. \n\n\n;See:\n:*   Details in the Wikipedia article:   Feigenbaum constant.\n\n", "solution": "using System;\n\nnamespace FeigenbaumConstant {\n    class Program {\n        static void Main(string[] args) {\n            var maxIt = 13;\n            var maxItJ = 10;\n            var a1 = 1.0;\n            var a2 = 0.0;\n            var d1 = 3.2;\n            Console.WriteLine(\" i       d\");\n            for (int i = 2; i <= maxIt; i++) {\n                var a = a1 + (a1 - a2) / d1;\n                for (int j = 1; j <= maxItJ; j++) {\n                    var x = 0.0;\n                    var y = 0.0;\n                    for (int k = 1; k <= 1<<i; k++) {\n                        y = 1.0 - 2.0 * y * x;\n                        x = a - x * x;\n                    }\n                    a -= x / y;\n                }\n                var d = (a1 - a2) / (a - a1);\n                Console.WriteLine(\"{0,2:d}    {1:f8}\", i, d);\n                d1 = d;\n                a2 = a1;\n                a1 = a;\n            }\n        }\n    }\n}"}
{"title": "Fibonacci n-step number sequences", "language": "C sharp|C#", "task": "These number series are an expansion of the ordinary [[Fibonacci sequence]] where:\n# For n = 2 we have the Fibonacci sequence; with initial values [1, 1] and F_k^2 = F_{k-1}^2 + F_{k-2}^2\n# For n = 3 we have the tribonacci sequence; with initial values [1, 1, 2] and F_k^3 = F_{k-1}^3 + F_{k-2}^3 + F_{k-3}^3\n# For n = 4 we have the tetranacci sequence; with initial values [1, 1, 2, 4] and F_k^4 = F_{k-1}^4 + F_{k-2}^4 + F_{k-3}^4 + F_{k-4}^4...\n# For general n>2 we have the Fibonacci n-step sequence - F_k^n; with initial values of the first n values of the (n-1)'th Fibonacci n-step sequence F_k^{n-1}; and k'th value of this n'th sequence being F_k^n = \\sum_{i=1}^{(n)} {F_{k-i}^{(n)}}\n\nFor small values of n, Greek numeric prefixes are sometimes used to individually name each series.\n\n:::: {| style=\"text-align: left;\" border=\"4\" cellpadding=\"2\" cellspacing=\"2\"\n|+ Fibonacci n-step sequences\n|- style=\"background-color: rgb(255, 204, 255);\"\n! n !! Series name !! Values\n|-\n|  2 ||  fibonacci || 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ...\n|-\n|  3 || tribonacci || 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ...\n|-\n|  4 || tetranacci || 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ...\n|-\n|  5 || pentanacci || 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ...\n|-\n|  6 ||  hexanacci || 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ...\n|-\n|  7 || heptanacci || 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ...\n|-\n|  8 ||  octonacci || 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ...\n|-\n|  9 ||  nonanacci || 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ...\n|-\n| 10 ||  decanacci || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ...\n|}\n\nAllied sequences can be generated where the initial values are changed:\n: '''The Lucas series''' sums the two preceding values like the fibonacci series for n=2 but uses [2, 1] as its initial values.\n\n\n\n;Task:\n# Write a function to generate Fibonacci n-step number sequences given its initial values and assuming the number of initial values determines how many previous values are summed to make the next number of the series.\n# Use this to print and show here at least the first ten members of the Fibo/tribo/tetra-nacci and Lucas sequences.\n\n\n;Related tasks:\n*   [[Fibonacci sequence]]\n*   Wolfram Mathworld\n*   [[Hofstadter Q sequence]]\n*   [[Leonardo numbers]]\n\n\n;Also see:\n*   Lucas Numbers - Numberphile (Video)\n*   Tribonacci Numbers (and the Rauzy Fractal) - Numberphile (Video)\n*   Wikipedia, Lucas number\n*   MathWorld, Fibonacci Number\n*   Some identities for r-Fibonacci numbers\n*   OEIS Fibonacci numbers\n*   OEIS Lucas numbers\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Fibonacci\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            PrintNumberSequence(\"Fibonacci\", GetNnacciNumbers(2, 10));\n            PrintNumberSequence(\"Lucas\", GetLucasNumbers(10));\n            PrintNumberSequence(\"Tribonacci\", GetNnacciNumbers(3, 10));\n            PrintNumberSequence(\"Tetranacci\", GetNnacciNumbers(4, 10));\n            Console.ReadKey();\n        }\n\n        private static IList<ulong> GetLucasNumbers(int length)\n        {\n            IList<ulong> seedSequence = new List<ulong>() { 2, 1 };\n            return GetFibLikeSequence(seedSequence, length);\n        }\n\n        private static IList<ulong> GetNnacciNumbers(int seedLength, int length)\n        {\n            return GetFibLikeSequence(GetNacciSeed(seedLength), length);\n        }\n\n        private static IList<ulong> GetNacciSeed(int seedLength)\n        {\n            IList<ulong> seedSquence = new List<ulong>() { 1 };\n\n            for (uint i = 0; i < seedLength - 1; i++)\n            {\n                seedSquence.Add((ulong)Math.Pow(2, i));\n            }\n\n            return seedSquence;\n        }\n\n        private static IList<ulong> GetFibLikeSequence(IList<ulong> seedSequence, int length)\n        {\n            IList<ulong> sequence = new List<ulong>();\n\n            int count = seedSequence.Count();\n\n            if (length <= count)\n            {\n                sequence = seedSequence.Take((int)length).ToList();\n            }\n            else\n            {\n                sequence = seedSequence;\n\n                for (int i = count; i < length; i++)\n                {\n                    ulong num = 0;\n\n                    for (int j = 0; j < count; j++)\n                    {\n                        num += sequence[sequence.Count - 1 - j];\n                    }\n\n                    sequence.Add(num);\n                }\n            }\n\n            return sequence;\n        }\n\n        private static void PrintNumberSequence(string Title, IList<ulong> numbersequence)\n        {\n            StringBuilder output = new StringBuilder(Title).Append(\"   \");\n\n            foreach (long item in numbersequence)\n            {\n                output.AppendFormat(\"{0}, \", item);\n            }\n\n            Console.WriteLine(output.ToString());\n        }\n    }\n}"}
{"title": "Fibonacci word", "language": "C sharp|C#", "task": "The   Fibonacci Word   may be created in a manner analogous to the   Fibonacci Sequence    as described here:\n\n     Define   F_Word1   as   '''1'''\n     Define   F_Word2   as   '''0'''\n     Form     F_Word3   as   F_Word2     concatenated with   F_Word1    i.e.:   '''01'''\n     Form     F_Wordn   as   F_Wordn-1   concatenated with   F_wordn-2\n\n\n;Task:\nPerform the above steps for     n = 37.\n\nYou may display the first few but not the larger values of   n.\n{Doing so will get the task's author into trouble with them what be (again!).} \n\nInstead, create a table for   F_Words   '''1'''   to   '''37'''   which shows:\n::*   The number of characters in the word\n::*   The word's [[Entropy]]\n\n\n;Related tasks:  \n*   Fibonacci word/fractal\n*   [[Entropy]]\n*   [[Entropy/Narcissist]]\n\n", "solution": "using SYS = System;\nusing SCG = System.Collections.Generic;\n\n//\n// Basically a port of the C++ solution as posted\n// 2017-11-12.\n//\nnamespace FibonacciWord\n{\n  class Program\n  {\n    static void Main( string[] args )\n    {\n      PrintHeading();\n      string firstString = \"1\";\n      int n = 1;\n      PrintLine( n, firstString );\n      string secondString = \"0\";\n      ++n;\n      PrintLine( n, secondString );\n      while ( n < 37 )\n      {\n        string resultString = firstString + secondString;\n        firstString = secondString;\n        secondString = resultString;\n        ++n;\n        PrintLine( n, resultString );\n      }\n    }\n\n    private static void PrintLine( int n, string result )\n    {\n      SYS.Console.Write( \"{0,-5}\", n );\n      SYS.Console.Write( \"{0,12}\", result.Length );\n      SYS.Console.WriteLine( \"  {0,-16}\", GetEntropy( result ) );\n    }\n\n    private static double GetEntropy( string result )\n    {\n      SCG.Dictionary<char, int> frequencies = new SCG.Dictionary<char, int>();\n      foreach ( char c in result )\n      {\n        if ( frequencies.ContainsKey( c ) )\n        {\n          ++frequencies[c];\n        }\n        else\n        {\n          frequencies[c] = 1;\n        }\n      }\n\n      int length = result.Length;\n      double entropy = 0;\n      foreach ( var keyValue in frequencies )\n      {\n        double freq = (double)keyValue.Value / length;\n        entropy += freq * SYS.Math.Log( freq, 2 );\n      }\n\n      return -entropy;\n    }\n\n    private static void PrintHeading()\n    {\n      SYS.Console.Write( \"{0,-5}\", \"N\" );\n      SYS.Console.Write( \"{0,12}\", \"Length\" );\n      SYS.Console.WriteLine( \"  {0,-16}\", \"Entropy\" );\n    }\n  }\n}"}
{"title": "Find limit of recursion", "language": "C sharp|C#", "task": "{{selection|Short Circuit|Console Program Basics}}\n\n \n\n\n;Task:\nFind the limit of recursion.\n\n", "solution": "using System;\nclass RecursionLimit\n{\n  static void Main(string[] args)\n  {\n    Recur(0);\n  }\n \n  private static void Recur(int i) \n  {\n    Console.WriteLine(i);\n    Recur(i + 1);\n  }\n}"}
{"title": "Find palindromic numbers in both binary and ternary bases", "language": "C sharp 3", "task": "*   Find and show (in decimal) the first six numbers (non-negative integers) that are   palindromes   in   ''both'':\n:::*   base 2\n:::*   base 3\n*   Display   '''0'''   (zero) as the first number found, even though some other definitions ignore it.\n*   Optionally, show the decimal number found in its binary and ternary form.\n*   Show all output here.\n\n\nIt's permissible to assume the first two numbers and simply list them.\n\n\n;See also\n*   Sequence A60792,   numbers that are palindromic in bases 2 and 3 on ''The On-Line Encyclopedia of Integer Sequences''.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic class FindPalindromicNumbers\n{\n    static void Main(string[] args)\n    {\n        var query =\n            PalindromicTernaries()\n            .Where(IsPalindromicBinary)\n            .Take(6);\n        foreach (var x in query) {\n            Console.WriteLine(\"Decimal: \" + x);\n            Console.WriteLine(\"Ternary: \" + ToTernary(x));\n            Console.WriteLine(\"Binary: \" + Convert.ToString(x, 2));\n            Console.WriteLine();\n        }\n    }\n\n    public static IEnumerable<long> PalindromicTernaries() {\n        yield return 0;\n        yield return 1;\n        yield return 13;\n        yield return 23;\n\n        var f = new List<long> {0};\n        long fMiddle = 9;\n        while (true) {\n            for (long edge = 1; edge < 3; edge++) {\n                int i;\n                do {\n                    //construct the result\n                    long result = fMiddle;\n                    long fLeft = fMiddle * 3;\n                    long fRight = fMiddle / 3;\n                    for (int j = f.Count - 1; j >= 0; j--) {\n                        result += (fLeft + fRight) * f[j];\n                        fLeft *= 3;\n                        fRight /= 3;\n                    }\n                    result += (fLeft + fRight) * edge;\n                    yield return result;\n\n                    //next permutation\n                    for (i = f.Count - 1; i >= 0; i--) {\n                        if (f[i] == 2) {\n                            f[i] = 0;\n                        } else {\n                            f[i]++;\n                            break;\n                        }\n                    }\n                } while (i >= 0);\n            }\n            f.Add(0);\n            fMiddle *= 3;\n        }\n    }\n\n    public static bool IsPalindromicBinary(long number) {\n        long n = number;\n        long reverse = 0;\n        while (n != 0) {\n            reverse <<= 1;\n            if ((n & 1) == 1) reverse++;\n            n >>= 1;\n        }\n        return reverse == number;\n    }\n\n    public static string ToTernary(long n)\n    {\n        if (n == 0) return \"0\";\n        string result = \"\";\n        while (n > 0) {        {\n            result = (n % 3) + result;\n            n /= 3;\n        }\n        return result;\n    }\n\n}"}
{"title": "Find the intersection of a line with a plane", "language": "C sharp|C#", "task": "Finding the intersection of an infinite ray with a plane in 3D is an important topic in collision detection.\n\n\n;Task:\nFind the point of intersection for the infinite ray with direction   (0, -1, -1)   passing through position   (0, 0, 10)   with the infinite plane with a normal vector of   (0, 0, 1)   and which passes through [0, 0, 5].\n\n", "solution": "using System;\n\nnamespace FindIntersection {\n    class Vector3D {\n        private double x, y, z;\n\n        public Vector3D(double x, double y, double z) {\n            this.x = x;\n            this.y = y;\n            this.z = z;\n        }\n\n        public static Vector3D operator +(Vector3D lhs, Vector3D rhs) {\n            return new Vector3D(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z);\n        }\n\n        public static Vector3D operator -(Vector3D lhs, Vector3D rhs) {\n            return new Vector3D(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z);\n        }\n\n        public static Vector3D operator *(Vector3D lhs, double rhs) {\n            return new Vector3D(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs);\n        }\n\n        public double Dot(Vector3D rhs) {\n            return x * rhs.x + y * rhs.y + z * rhs.z;\n        }\n\n        public override string ToString() {\n            return string.Format(\"({0:F}, {1:F}, {2:F})\", x, y, z);\n        }\n    }\n\n    class Program {\n        static Vector3D IntersectPoint(Vector3D rayVector, Vector3D rayPoint, Vector3D planeNormal, Vector3D planePoint) {\n            var diff = rayPoint - planePoint;\n            var prod1 = diff.Dot(planeNormal);\n            var prod2 = rayVector.Dot(planeNormal);\n            var prod3 = prod1 / prod2;\n            return rayPoint - rayVector * prod3;\n        }\n\n        static void Main(string[] args) {\n            var rv = new Vector3D(0.0, -1.0, -1.0);\n            var rp = new Vector3D(0.0, 0.0, 10.0);\n            var pn = new Vector3D(0.0, 0.0, 1.0);\n            var pp = new Vector3D(0.0, 0.0, 5.0);\n            var ip = IntersectPoint(rv, rp, pn, pp);\n            Console.WriteLine(\"The ray intersects the plane at {0}\", ip);\n        }\n    }\n}"}
{"title": "Find the intersection of two lines", "language": "C sharp|C#", "task": "Finding the intersection of two lines that are in the same plane is an important topic in collision detection.[http://mathworld.wolfram.com/Line-LineIntersection.html]\n\n;Task:\nFind the point of intersection of two lines in 2D. \n\n\nThe 1st     line passes though    (4,0)    and    (6,10) . \nThe 2nd line passes though    (0,3)    and    (10,7) .\n\n", "solution": "using System;\nusing System.Drawing;\npublic class Program\n{\n    static PointF FindIntersection(PointF s1, PointF e1, PointF s2, PointF e2) {\n        float a1 = e1.Y - s1.Y;\n        float b1 = s1.X - e1.X;\n        float c1 = a1 * s1.X + b1 * s1.Y;\n\n        float a2 = e2.Y - s2.Y;\n        float b2 = s2.X - e2.X;\n        float c2 = a2 * s2.X + b2 * s2.Y;\n\n        float delta = a1 * b2 - a2 * b1;\n        //If lines are parallel, the result will be (NaN, NaN).\n        return delta == 0 ? new PointF(float.NaN, float.NaN)\n            : new PointF((b2 * c1 - b1 * c2) / delta, (a1 * c2 - a2 * c1) / delta);\n    }\n\n    static void Main() {\n        Func<float, float, PointF> p = (x, y) => new PointF(x, y);\n        Console.WriteLine(FindIntersection(p(4f, 0f), p(6f, 10f), p(0f, 3f), p(10f, 7f)));\n        Console.WriteLine(FindIntersection(p(0f, 0f), p(1f, 1f), p(1f, 2f), p(4f, 5f)));\n    }\n}"}
{"title": "Find the last Sunday of each month", "language": "C sharp|C#", "task": "Write a program or a script that returns the last Sundays of each month of a given year. The year may be given through any simple input method in your language (command line, std in, etc).\n\nExample of an expected output:\n\n./last_sundays 2013\n2013-01-27\n2013-02-24\n2013-03-31\n2013-04-28\n2013-05-26\n2013-06-30\n2013-07-28\n2013-08-25\n2013-09-29\n2013-10-27\n2013-11-24\n2013-12-29\n\n;Related tasks\n* [[Day of the week]]\n* [[Five weekends]]\n* [[Last Friday of each month]]\n\n", "solution": "using System;\n\nnamespace LastSundayOfEachMonth\n{\n    class Program\n    {\n        static void Main()\n        {\n            Console.Write(\"Year to calculate: \");\n\n            string strYear = Console.ReadLine();\n            int year = Convert.ToInt32(strYear);\n\n            DateTime date;\n            for (int i = 1; i <= 12; i++)\n            {\n                date = new DateTime(year, i, DateTime.DaysInMonth(year, i), System.Globalization.CultureInfo.CurrentCulture.Calendar);\n                /* Modification by Albert Zakhia on 2021-16-02\n                   The below code is very slow due to the loop, we will go twice as fast\n                while (date.DayOfWeek != DayOfWeek.Sunday)\n                {\n                    date = date.AddDays(-1);\n                }\n                */\n                // The updated code\n                int daysOffset = date.DayOfWeek - dayOfWeek; // take the offset to subtract directly instead of looping\n                if (daysOffset < 0) daysOffset += 7; // if the code is negative, we need to normalize them\n                date = date.AddDays(-daysOffset ); // now just add the days offset\n                Console.WriteLine(date.ToString(\"yyyy-MM-dd\"));\n            }\n        }\n    }\n}\n"}
{"title": "Find the missing permutation", "language": "C sharp", "task": "ABCD\n                    CABD\n                    ACDB\n                    DACB\n                    BCDA\n                    ACBD\n                    ADCB\n                    CDAB\n                    DABC\n                    BCAD\n                    CADB\n                    CDBA\n                    CBAD\n                    ABDC\n                    ADBC\n                    BDCA\n                    DCBA\n                    BACD\n                    BADC\n                    BDAC\n                    CBDA\n                    DBCA\n                    DCAB\n\n\nListed above are   all-but-one   of the permutations of the symbols   '''A''',   '''B''',   '''C''',   and   '''D''',   ''except''   for one permutation that's   ''not''   listed.  \n\n\n;Task:\nFind that missing permutation.\n\n\n;Methods:\n* Obvious method: \n         enumerate all permutations of   '''A''',  '''B''',  '''C''',  and  '''D''',  \n         and then look for the missing permutation. \n\n* alternate method:\n         Hint:  if all permutations were shown above,  how many \n         times would  '''A'''  appear in each position?     \n         What is the  ''parity''  of this number?\n\n* another alternate method:\n         Hint:  if you add up the letter values of each column, \n         does a missing letter   '''A''',  '''B''',  '''C''',  and  '''D'''   from each\n         column cause the total value for each column to be unique?\n\n\n;Related task:\n*   [[Permutations]])\n\n", "solution": "using System;\nusing System.Linq;\n\npublic class Test\n{\n    public static void Main()\n    {\n        var input = new [] {\"ABCD\",\"CABD\",\"ACDB\",\"DACB\",\"BCDA\",\n            \"ACBD\",\"ADCB\",\"CDAB\",\"DABC\",\"BCAD\",\"CADB\",\n            \"CDBA\",\"CBAD\",\"ABDC\",\"ADBC\",\"BDCA\",\"DCBA\",\n            \"BACD\",\"BADC\",\"BDAC\",\"CBDA\",\"DBCA\",\"DCAB\"};\n        \n        int[] values = {0,0,0,0};\n        foreach (string s in input)\n            for (int i = 0; i < 4; i++)\n                values[i] ^= s[i];\n        Console.WriteLine(string.Join(\"\", values.Select(i => (char)i)));\n    }\n}"}
{"title": "First-class functions/Use numbers analogously", "language": "C# 4.0", "task": "In [[First-class functions]], a language is showing how its manipulation of functions is similar to its manipulation of other types.\n\nThis tasks aim is to compare and contrast a language's implementation of first class functions, with its normal handling of numbers.\n\n\nWrite a program to create an ordered collection of a mixture of literally typed and expressions producing a real number, together with another ordered collection of their multiplicative inverses. Try and use the following pseudo-code to generate the numbers for the ordered collections:\n   x  = 2.0\n   xi = 0.5\n   y  = 4.0\n   yi = 0.25\n   z  = x + y\n   zi = 1.0 / ( x + y )\n\nCreate a function ''multiplier'', that given two numbers as arguments returns a function that when called with one argument, returns the result of multiplying the two arguments to the call to multiplier that created it and the argument in the call:\n  new_function = multiplier(n1,n2)\n  # where new_function(m) returns the result of n1 * n2 * m\n\nApplying the multiplier of a number and its inverse from the two ordered collections of numbers in pairs, show that the result in each case is one.\n'''Compare and contrast the resultant program with the corresponding entry in [[First-class functions]].''' They should be close.\n\nTo paraphrase the task description: Do what was done before, but with numbers rather than functions\n\n", "solution": "using System;\nusing System.Linq;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        double x, xi, y, yi, z, zi;\n        x = 2.0;\n        xi = 0.5;\n        y = 4.0;\n        yi = 0.25;\n        z = x + y;\n        zi = 1.0 / (x + y);\n\n        var numlist = new[] { x, y, z };\n        var numlisti = new[] { xi, yi, zi };\n        var multiplied = numlist.Zip(numlisti, (n1, n2) =>\n                       {\n                           Func<double, double> multiplier = m => n1 * n2 * m;\n                           return multiplier;\n                       });\n\n        foreach (var multiplier in multiplied)\n            Console.WriteLine(multiplier(0.5));\n    }\n}\n"}
{"title": "First perfect square in base n with n unique digits", "language": "C sharp|C# from Visual Basic .NET", "task": "Find the first perfect square in a given base '''N''' that has at least '''N''' digits and\nexactly '''N''' ''significant unique'' digits when expressed in base '''N'''.\n\nE.G. In base '''10''', the first perfect square with at least '''10''' unique digits is '''1026753849''' ('''320432''').\n\nYou may use analytical methods to reduce the search space, but the code must do a search. Do not use magic numbers or just feed the code the answer to verify it is correct.\n\n;Task\n\n* Find and display here, on this page, the first perfect square in base '''N''', with '''N''' significant unique digits when expressed in base '''N''', for each of base '''2''' through '''12'''. Display each number in the base '''N''' for which it was calculated.\n\n* (optional) Do the same for bases '''13''' through '''16'''.\n\n* (stretch goal) Continue on for bases '''17''' - '''??''' (Big Integer math)\n\n\n;See also:\n\n;* OEIS A260182: smallest square that is pandigital in base n.\n\n;Related task\n\n;* [[Casting out nines]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Numerics;\n\nstatic class Program\n{\n    static byte Base, bmo, blim, ic; static DateTime st0; static BigInteger bllim, threshold;\n    static HashSet<byte> hs = new HashSet<byte>(), o = new HashSet<byte>();\n    static string chars = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz|\";\n    static List<BigInteger> limits;\n    static string ms;\n\n    // convert BigInteger to string using current base\n    static string toStr(BigInteger b) {\n        string res = \"\"; BigInteger re; while (b > 0) {\n            b = BigInteger.DivRem(b, Base, out re); res = chars[(byte)re] + res;\n        } return res;\n    }\n\n    // check for a portion of digits, bailing if uneven\n    static bool allInQS(BigInteger b) {\n        BigInteger re; int c = ic; hs.Clear(); hs.UnionWith(o); while (b > bllim) {\n            b = BigInteger.DivRem(b, Base, out re);\n            hs.Add((byte)re); c += 1; if (c > hs.Count) return false;\n        } return true;\n    }\n\n    // check for a portion of digits, all the way to the end\n    static bool allInS(BigInteger b) {\n        BigInteger re; hs.Clear(); hs.UnionWith(o); while (b > bllim) {\n            b = BigInteger.DivRem(b, Base, out re); hs.Add((byte)re);\n        } return hs.Count == Base;\n    }\n\n    // check for all digits, bailing if uneven\n    static bool allInQ(BigInteger b) {\n        BigInteger re; int c = 0; hs.Clear(); while (b > 0) {\n            b = BigInteger.DivRem(b, Base, out re);\n            hs.Add((byte)re); c += 1; if (c > hs.Count) return false;\n        } return true;\n    }\n\n    // check for all digits, all the way to the end\n    static bool allIn(BigInteger b) {\n        BigInteger re; hs.Clear(); while (b > 0) {\n            b = BigInteger.DivRem(b, Base, out re); hs.Add((byte)re);\n        } return hs.Count == Base;\n    }\n\n    // parse a string into a BigInteger, using current base\n    static BigInteger to10(string s) {\n        BigInteger res = 0; foreach (char i in s) res = res * Base + chars.IndexOf(i);\n        return res;\n    }\n\n    // returns the minimum value string, optionally inserting extra digit\n    static string fixup(int n) {\n        string res = chars.Substring(0, Base); if (n > 0) res = res.Insert(n, n.ToString());\n        return \"10\" + res.Substring(2);\n    }\n\n    // checks the square against the threshold, advances various limits when needed\n    static void check(BigInteger sq) {\n        if (sq > threshold) {\n            o.Remove((byte)chars.IndexOf(ms[blim])); blim -= 1; ic -= 1;\n            threshold = limits[bmo - blim - 1]; bllim = to10(ms.Substring(0, blim + 1));\n        }\n    }\n\n    // performs all the caclulations for the current base\n    static void doOne() {\n        limits = new List<BigInteger>();\n        bmo = (byte)(Base - 1); byte dr = 0; if ((Base & 1) == 1) dr = (byte)(Base >> 1);\n        o.Clear(); blim = 0;\n        byte id = 0; int inc = 1; long i = 0; DateTime st = DateTime.Now; if (Base == 2) st0 = st;\n        byte[] sdr = new byte[bmo]; byte rc = 0; for (i = 0; i < bmo; i++) {\n            sdr[i] = (byte)((i * i) % bmo); rc += sdr[i] == dr ? (byte)1 : (byte)0;\n            sdr[i] += sdr[i] == 0 ? bmo : (byte)0;\n        } i = 0; if (dr > 0) {\n            id = Base;\n            for (i = 1; i <= dr; i++) if (sdr[i] >= dr) if (id > sdr[i]) id = sdr[i]; id -= dr;\n            i = 0;\n        } ms = fixup(id);\n        BigInteger sq = to10(ms); BigInteger rt = new BigInteger(Math.Sqrt((double)sq) + 1);\n        sq = rt * rt; if (Base > 9) {\n            for (int j = 1; j < Base; j++)\n                limits.Add(to10(ms.Substring(0, j) + new string(chars[bmo], Base - j + (rc > 0 ? 0 : 1))));\n            limits.Reverse(); while (sq < limits[0]) { rt++; sq = rt * rt; }\n        }\n        BigInteger dn = (rt << 1) + 1; BigInteger d = 1; if (Base > 3 && rc > 0) {\n            while (sq % bmo != dr) { rt += 1; sq += dn; dn += 2; } // alligns sq to dr\n            inc = bmo / rc;\n            if (inc > 1) { dn += rt * (inc - 2) - 1; d = inc * inc; }\n            dn += dn + d;\n        }\n        d <<= 1; if (Base > 9) {\n            blim = 0; while (sq < limits[bmo - blim - 1]) blim++; ic = (byte)(blim + 1);\n            threshold = limits[bmo - blim - 1];\n            if (blim > 0) for (byte j = 0; j <= blim; j++) o.Add((byte)chars.IndexOf(ms[j]));\n            if (blim > 0) bllim = to10(ms.Substring(0, blim + 1)); else bllim = 0;\n            if (Base > 5 && rc > 0)\n                do { if (allInQS(sq)) break; sq += dn; dn += d; i += 1; check(sq); } while (true);\n            else\n                do { if (allInS(sq)) break; sq += dn; dn += d; i += 1; check(sq); } while (true);\n        } else {\n            if (Base > 5 && rc > 0)\n                do { if (allInQ(sq)) break; sq += dn; dn += d; i += 1; } while (true);\n            else\n                do { if (allIn(sq)) break; sq += dn; dn += d; i += 1; } while (true);\n        } rt += i * inc;\n        Console.WriteLine(\"{0,3}  {1,2}  {2,2} {3,20} -> {4,-40} {5,10} {6,9:0.0000}s  {7,9:0.0000}s\",\n            Base, inc, (id > 0 ? chars.Substring(id, 1) : \" \"), toStr(rt), toStr(sq), i,\n            (DateTime.Now - st).TotalSeconds, (DateTime.Now - st0).TotalSeconds);\n    }\n\n    static void Main(string[] args) {\n        Console.WriteLine(\"base inc id                 root    square\" +\n            \"                                   test count    time        total\");\n        for (Base = 2; Base <= 28; Base++) doOne();\n        Console.WriteLine(\"Elasped time was {0,8:0.00} minutes\", (DateTime.Now - st0).TotalMinutes);\n    }\n}"}
{"title": "First power of 2 that has leading decimal digits of 12", "language": "C sharp|C# from C++", "task": "(This task is taken from a   ''Project Euler''   problem.)\n\n(All numbers herein are expressed in base ten.)\n\n\n'''27   =   128'''   and   '''7'''   is\nthe first power of   '''2'''   whose leading decimal digits are   '''12'''.\n\nThe next power of   '''2'''   whose leading decimal digits\nare   '''12'''   is   '''80''',\n'''280   =   1208925819614629174706176'''.\n\n\nDefine     '''  '' p''(''L,n'')'''      to be the ''' ''n''th'''-smallest\nvalue of   ''' ''j'' '''   such that the base ten representation\nof    '''2''j'''''    begins with the digits of   ''' ''L'' '''.\n\n     So   ''p''(12, 1) =  7    and\n          ''p''(12, 2) = 80\n\n\nYou are also given that:\n          ''p''(123, 45)   =   12710\n\n\n;Task:\n::*   find: \n:::::*     '''   ''p''(12,  1)        ''' \n:::::*     '''   ''p''(12,  2)        ''' \n:::::*     '''   ''p''(123, 45)       ''' \n:::::*     '''   ''p''(123, 12345)    ''' \n:::::*     '''   ''p''(123, 678910)   ''' \n::*   display the results here, on this page.\n\n", "solution": "// a mini chrestomathy solution\n\nusing System;\n\nclass Program {\n\n    // translated from java example\n    static long js(int l, int n) {\n        long res = 0, f = 1;\n        double lf = Math.Log10(2);\n        for (int i = l; i > 10; i /= 10) f *= 10;\n        while (n > 0)\n            if ((int)(f * Math.Pow(10, ++res * lf % 1)) == l) n--;\n        return res;\n    }\n\n    // translated from go integer example (a.k.a. go translation of pascal alternative example)\n    static long gi(int ld, int n) {\n        string Ls = ld.ToString();\n        long res = 0, count = 0, f = 1;\n        for (int i = 1; i <= 18 - Ls.Length; i++) f *= 10;\n        const long ten18 = (long)1e18; long probe = 1;\n        do {\n            probe <<= 1; res++; if (probe >= ten18)\n                do {\n                    if (probe >= ten18) probe /= 10;\n                    if (probe / f == ld)\n                        if (++count >= n) { count--; break; }\n                    probe <<= 1; res++;\n                } while (true);\n            string ps = probe.ToString();\n            if (ps.Substring(0, Math.Min(Ls.Length, ps.Length)) == Ls)\n                if (++count >= n) break;\n        } while (true);\n        return res;\n    }\n\n    // translated from pascal alternative example\n    static long pa(int ld, int n) {\n        double L_float64 = Math.Pow(2, 64);\n        ulong Log10_2_64 = (ulong)(L_float64 * Math.Log10(2));\n        double Log10Num; ulong LmtUpper, LmtLower, Frac64;\n        long res = 0, dgts = 1, cnt;\n        for (int i = ld; i >= 10; i /= 10) dgts *= 10;\n        Log10Num = Math.Log10((ld + 1.0) / dgts);\n        // '316' was a limit\n        if (Log10Num >= 0.5) {\n            LmtUpper = (ld + 1.0) / dgts < 10.0 ? (ulong)(Log10Num * (L_float64 * 0.5)) * 2 + (ulong)(Log10Num * 2) : 0;\n            Log10Num = Math.Log10((double)ld / dgts);\n            LmtLower = (ulong)(Log10Num * (L_float64 * 0.5)) * 2 + (ulong)(Log10Num * 2);\n        } else {\n            LmtUpper = (ulong)(Log10Num * L_float64);\n            LmtLower = (ulong)(Math.Log10((double)ld / dgts) * L_float64);\n        }\n        cnt = 0; Frac64 = 0; if (LmtUpper != 0)\n            do {\n                res++; Frac64 += Log10_2_64;\n                if ((Frac64 >= LmtLower) & (Frac64 < LmtUpper))\n                    if (++cnt >= n) break;\n            } while (true);\n        else // '999..'\n            do {\n                res++; Frac64 += Log10_2_64;\n                if (Frac64 >= LmtLower) if (++cnt >= n) break;\n            } while (true);\n        return res;\n    }\n\n    static int[] values = new int[] { 12, 1, 12, 2, 123, 45, 123, 12345, 123, 678910, 99, 1 };\n\n    static void doOne(string name, Func<int, int, long> fun) {\n        Console.WriteLine(\"{0} version:\", name);\n        var start = DateTime.Now;\n        for (int i = 0; i < values.Length; i += 2)\n            Console.WriteLine(\"p({0,3}, {1,6}) = {2,11:n0}\", values[i], values[i + 1], fun(values[i], values[i + 1]));\n        Console.WriteLine(\"Took {0} seconds\\n\", DateTime.Now - start);\n    }\n\n    static void Main() {\n        doOne(\"java simple\", js);\n        doOne(\"go integer\", gi);\n        doOne(\"pascal alternative\", pa);\n    }\n}"}
{"title": "Fivenum", "language": "C sharp|C# from Java", "task": "Many big data or scientific programs use boxplots to show distributions of data.   In addition, sometimes saving large arrays for boxplots can be impractical and use extreme amounts of RAM.   It can be useful to save large arrays as arrays with five numbers to save memory.\n\nFor example, the   '''R'''   programming language implements Tukey's five-number summary as the '''fivenum''' function.\n\n\n;Task:\nGiven an array of numbers, compute the five-number summary.\n\n\n;Note:  \nWhile these five numbers can be used to draw a boxplot,   statistical packages will typically need extra data. \n\nMoreover, while there is a consensus about the \"box\" of the boxplot,   there are variations among statistical packages for the whiskers.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Fivenum {\n    public static class Helper {\n        public static string AsString<T>(this ICollection<T> c, string format = \"{0}\") {\n            StringBuilder sb = new StringBuilder(\"[\");\n            int count = 0;\n            foreach (var t in c) {\n                if (count++ > 0) {\n                    sb.Append(\", \");\n                }\n                sb.AppendFormat(format, t);\n            }\n            return sb.Append(\"]\").ToString();\n        }\n    }\n\n    class Program {\n        static double Median(double[] x, int start, int endInclusive) {\n            int size = endInclusive - start + 1;\n            if (size <= 0) throw new ArgumentException(\"Array slice cannot be empty\");\n            int m = start + size / 2;\n            return (size % 2 == 1) ? x[m] : (x[m - 1] + x[m]) / 2.0;\n        }\n\n        static double[] Fivenum(double[] x) {\n            foreach (var d in x) {\n                if (Double.IsNaN(d)) {\n                    throw new ArgumentException(\"Unable to deal with arrays containing NaN\");\n                }\n            }\n            double[] result = new double[5];\n            Array.Sort(x);\n            result[0] = x.First();\n            result[2] = Median(x, 0, x.Length - 1);\n            result[4] = x.Last();\n            int m = x.Length / 2;\n            int lowerEnd = (x.Length % 2 == 1) ? m : m - 1;\n            result[1] = Median(x, 0, lowerEnd);\n            result[3] = Median(x, m, x.Length - 1);\n            return result;\n        }\n\n        static void Main(string[] args) {\n            double[][] x1 = new double[][]{\n                new double[]{ 15.0, 6.0, 42.0, 41.0, 7.0, 36.0, 49.0, 40.0, 39.0, 47.0, 43.0},\n                new double[]{ 36.0, 40.0, 7.0, 39.0, 41.0, 15.0},\n                new double[]{\n                     0.14082834,  0.09748790,  1.73131507,  0.87636009, -1.95059594,  0.73438555,\n                    -0.03035726,  1.46675970, -0.74621349, -0.72588772,  0.63905160,  0.61501527,\n                    -0.98983780, -1.00447874, -0.62759469,  0.66206163,  1.04312009, -0.10305385,\n                     0.75775634,  0.32566578\n                },\n            };\n            foreach(var x in x1) {\n                var result = Fivenum(x);\n                Console.WriteLine(result.AsString(\"{0:F8}\"));\n            }\n        }\n    }\n}"}
{"title": "Flatten a list", "language": "C sharp", "task": "Write a function to flatten the nesting in an arbitrary list of values. \n\nYour program should work on the equivalent of this list:\n   [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]\nWhere the correct result would be the list:\n    [1, 2, 3, 4, 5, 6, 7, 8]\n\n;Related task:\n*   [[Tree traversal]]\n\n", "solution": "public static class Ex {\n\t\tpublic static List<object> Flatten(this List<object> list) {\n\n\t\t\tvar result = new List<object>();\n\t\t\tforeach (var item in list) {\n\t\t\t\tif (item is List<object>) {\n\t\t\t\t\tresult.AddRange(Flatten(item as List<object>));\n\t\t\t\t} else {\n\t\t\t\t\tresult.Add(item);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t\tpublic static string Join<T>(this List<T> list, string glue) {\n\t\t\treturn string.Join(glue, list.Select(i => i.ToString()).ToArray());\n\t\t}\n\t}\n\n\tclass Program {\n\n\t\tstatic void Main(string[] args) {\n\t\t\tvar list = new List<object>{new List<object>{1}, 2, new List<object>{new List<object>{3,4}, 5}, new List<object>{new List<object>{new List<object>{}}}, new List<object>{new List<object>{new List<object>{6}}}, 7, 8, new List<object>{}};\n\n\t\t\tConsole.WriteLine(\"[\" + list.Flatten().Join(\", \") + \"]\");\n\t\t\tConsole.ReadLine();\n\t\t}\n\t}\n"}
{"title": "Floyd's triangle", "language": "C sharp|C# from Perl", "task": "Floyd's triangle   lists the natural numbers in a right triangle aligned to the left where \n* the first row is   '''1'''     (unity)\n* successive rows start towards the left with the next number followed by successive naturals listing one more number than the line above.\n\n\nThe first few lines of a Floyd triangle looks like this:\n\n 1\n 2  3\n 4  5  6\n 7  8  9 10\n11 12 13 14 15\n\n\n\n;Task:\n:# Write a program to generate and display here the first   n   lines of a Floyd triangle. (Use   n=5   and   n=14   rows).\n:# Ensure that when displayed in a mono-space font, the numbers line up in vertical columns as shown and that only one space separates numbers of the last row.\n\n", "solution": "using System;\nusing System.Text;\n\npublic class FloydsTriangle\n{\n    internal static void Main(string[] args)\n    {\n        int count;\n        if (args.Length >= 1 && int.TryParse(args[0], out count) && count > 0)\n        {\n            Console.WriteLine(MakeTriangle(count));\n        }\n        else\n        {\n            Console.WriteLine(MakeTriangle(5));\n            Console.WriteLine();\n            Console.WriteLine(MakeTriangle(14));\n        }\n    }\n\n    public static string MakeTriangle(int rows)\n    {\n        int maxValue = (rows * (rows + 1)) / 2;\n        int digit = 0;\n        StringBuilder output = new StringBuilder();\n\n        for (int row = 1; row <= rows; row++)\n        {\n            for (int column = 0; column < row; column++)\n            {\n                int colMaxDigit = (maxValue - rows) + column + 1;\n                if (column > 0)\n                {\n                    output.Append(' ');\n                }\n\n                digit++;\n                output.Append(digit.ToString().PadLeft(colMaxDigit.ToString().Length));\n            }\n\n            output.AppendLine();\n        }\n\n        return output.ToString();\n    }\n}"}
{"title": "Four bit adder", "language": "C sharp", "task": "\"''Simulate''\" a four-bit adder.\n \nThis design can be realized using four 1-bit full adders. \nEach of these 1-bit full adders can be built with two gate. ; \n\nFinally a half adder can be made using an   ''xor''   gate and an   ''and''   gate. \n\nThe   ''xor''   gate can be made using two   ''not''s,   two   ''and''s   and one   ''or''.\n\n'''Not''',   '''or'''   and   '''and''',   the only allowed \"gates\" for the task, can be \"imitated\" by using the bitwise operators of your language. \n\nIf there is not a ''bit type'' in your language, to be sure that the   ''not''   does not \"invert\" all the other bits of the basic type   (e.g. a byte)   we are not interested in,   you can use an extra   ''nand''   (''and''   then   ''not'')   with the constant   '''1'''   on one input.\n\nInstead of optimizing and reducing the number of gates used for the final 4-bit adder,   build it in the most straightforward way,   ''connecting'' the other \"constructive blocks\",   in turn made of \"simpler\" and \"smaller\" ones.\n\n{|\n|+Schematics of the \"constructive blocks\"\n!(Xor gate with ANDs, ORs and NOTs)        \n!   (A half adder)                \n!          (A full adder)            \n!                (A 4-bit adder)                           \n|-\n|Xor gate done with ands, ors and nots\n|A half adder\n|A full adder\n|A 4-bit adder\n|}\n\n\n\nSolutions should try to be as descriptive as possible, making it as easy as possible to identify \"connections\" between higher-order \"blocks\". \n\nIt is not mandatory to replicate the syntax of higher-order blocks in the atomic \"gate\" blocks, i.e. basic \"gate\" operations can be performed as usual bitwise operations, or they can be \"wrapped\" in a ''block'' in order to expose the same syntax of higher-order blocks, at implementers' choice.\n\nTo test the implementation, show the sum of two four-bit numbers (in binary).\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace RosettaCodeTasks.FourBitAdder\n{\n\tpublic struct BitAdderOutput\n\t{\n\t\tpublic bool S { get; set; }\n\t\tpublic bool C { get; set; }\n\t\tpublic override string ToString ( )\n\t\t{\n\t\t\treturn \"S\" + ( S ? \"1\" : \"0\" ) + \"C\" + ( C ? \"1\" : \"0\" );\n\t\t}\n\t}\n\tpublic struct Nibble\n\t{\n\t\tpublic bool _1 { get; set; }\n\t\tpublic bool _2 { get; set; }\n\t\tpublic bool _3 { get; set; }\n\t\tpublic bool _4 { get; set; }\n\t\tpublic override string ToString ( )\n\t\t{\n\t\t\treturn ( _4 ? \"1\" : \"0\" )\n\t\t\t\t+ ( _3 ? \"1\" : \"0\" )\n\t\t\t\t+ ( _2 ? \"1\" : \"0\" )\n\t\t\t\t+ ( _1 ? \"1\" : \"0\" );\n\t\t}\n\t}\n\tpublic struct FourBitAdderOutput\n\t{\n\t\tpublic Nibble N { get; set; }\n\t\tpublic bool C { get; set; }\n\t\tpublic override string ToString ( )\n\t\t{\n\t\t\treturn N.ToString ( ) + \"c\" + ( C ? \"1\" : \"0\" );\n\t\t}\n\t}\n\n\tpublic static class LogicGates\n\t{\n\t\t// Basic Gates\n\t\tpublic static bool Not ( bool A ) { return !A; }\n\t\tpublic static bool And ( bool A, bool B ) { return A && B; }\n\t\tpublic static bool Or ( bool A, bool B ) { return A || B; }\n\n\t\t// Composite Gates\n\t\tpublic static bool Xor ( bool A, bool B ) {\treturn Or ( And ( A, Not ( B ) ), ( And ( Not ( A ), B ) ) ); }\n\t}\n\n\tpublic static class ConstructiveBlocks\n\t{\n\t\tpublic static BitAdderOutput HalfAdder ( bool A, bool B )\n\t\t{\n\t\t\treturn new BitAdderOutput ( ) { S = LogicGates.Xor ( A, B ), C = LogicGates.And ( A, B ) };\n\t\t}\n\n\t\tpublic static BitAdderOutput FullAdder ( bool A, bool B, bool CI )\n\t\t{\n\t\t\tBitAdderOutput HA1 = HalfAdder ( CI, A );\n\t\t\tBitAdderOutput HA2 = HalfAdder ( HA1.S, B );\n\n\t\t\treturn new BitAdderOutput ( ) { S = HA2.S, C = LogicGates.Or ( HA1.C, HA2.C ) };\n\t\t}\n\n\t\tpublic static FourBitAdderOutput FourBitAdder ( Nibble A, Nibble B, bool CI )\n\t\t{\n\n\t\t\tBitAdderOutput FA1 = FullAdder ( A._1, B._1, CI );\n\t\t\tBitAdderOutput FA2 = FullAdder ( A._2, B._2, FA1.C );\n\t\t\tBitAdderOutput FA3 = FullAdder ( A._3, B._3, FA2.C );\n\t\t\tBitAdderOutput FA4 = FullAdder ( A._4, B._4, FA3.C );\n\n\t\t\treturn new FourBitAdderOutput ( ) { N = new Nibble ( ) { _1 = FA1.S, _2 = FA2.S, _3 = FA3.S, _4 = FA4.S }, C = FA4.C };\n\t\t}\n\n\t\tpublic static void Test ( )\n\t\t{\n\t\t\tConsole.WriteLine ( \"Four Bit Adder\" );\n\n\t\t\tfor ( int i = 0; i < 256; i++ )\n\t\t\t{\n\t\t\t\tNibble A = new Nibble ( ) { _1 = false, _2 = false, _3 = false, _4 = false };\n\t\t\t\tNibble B = new Nibble ( ) { _1 = false, _2 = false, _3 = false, _4 = false };\n\t\t\t\tif ( (i & 1) == 1)\n\t\t\t\t{\n\t\t\t\t\tA._1 = true;\n\t\t\t\t}\n\t\t\t\tif ( ( i & 2 ) == 2 )\n\t\t\t\t{\n\t\t\t\t\tA._2 = true;\n\t\t\t\t}\n\t\t\t\tif ( ( i & 4 ) == 4 )\n\t\t\t\t{\n\t\t\t\t\tA._3 = true;\n\t\t\t\t}\n\t\t\t\tif ( ( i & 8 ) == 8 )\n\t\t\t\t{\n\t\t\t\t\tA._4 = true;\n\t\t\t\t}\n\t\t\t\tif ( ( i & 16 ) == 16 )\n\t\t\t\t{\n\t\t\t\t\tB._1 = true;\n\t\t\t\t}\n\t\t\t\tif ( ( i & 32 ) == 32)\n\t\t\t\t{\n\t\t\t\t\tB._2 = true;\n\t\t\t\t}\n\t\t\t\tif ( ( i & 64 ) == 64 )\n\t\t\t\t{\n\t\t\t\t\tB._3 = true;\n\t\t\t\t}\n\t\t\t\tif ( ( i & 128 ) == 128 )\n\t\t\t\t{\n\t\t\t\t\tB._4 = true;\n\t\t\t\t}\n\n\t\t\t\tConsole.WriteLine ( \"{0} + {1} = {2}\", A.ToString ( ), B.ToString ( ), FourBitAdder( A, B, false ).ToString ( ) );\n\n\t\t\t}\n\n\t\t\tConsole.WriteLine ( );\n\t\t}\n\n\t}\n}\n\n"}
{"title": "Function prototype", "language": "C sharp|C#", "task": "Some languages provide the facility to declare functions and subroutines through the use of function prototyping. \n\n\n;Task:\nDemonstrate the methods available for declaring prototypes within the language. The provided solutions should include:\n\n* An explanation of any placement restrictions for prototype declarations\n* A prototype declaration for a function that does not require arguments\n* A prototype declaration for a function that requires two arguments\n* A prototype declaration for a function that utilizes varargs\n* A prototype declaration for a function that utilizes optional arguments\n* A prototype declaration for a function that utilizes named parameters\n* Example of prototype declarations for subroutines or procedures (if these differ from functions)\n* An explanation and example of any special forms of prototyping not covered by the above\n\n\nLanguages that do not provide function prototyping facilities should be omitted from this task.\n\n", "solution": "using System;\npublic delegate int IntFunction(int a, int b);\n\npublic class Program\n{\n    public static int Add(int x, int y) {\n        return x + y;\n    }\n\n    public static int Multiply(int x, int y) {\n        return x * y;\n    }\n\n    public static void Main() {\n        IntFunction func = Add;\n        Console.WriteLine(func(2, 3)); //prints 5\n        func = Multiply;\n        Console.WriteLine(func(2, 3)); //prints 6\n        func += Add;\n        Console.WriteLine(func(2, 3)); //prints 5. Both functions are called, but only the last result is kept.\n    }\n}"}
{"title": "Fusc sequence", "language": "C sharp|C#", "task": "Definitions:\nThe   '''fusc'''   integer sequence is defined as:\n::*   fusc(0) = 0\n::*   fusc(1) = 1\n::*   for '''n'''>1,   the   '''n'''th   term is defined as:\n::::*   if   '''n'''   is       even;     fusc(n) = fusc(n/2)\n::::*   if   '''n'''   is   odd;     fusc(n) = fusc((n-1)/2)   +   fusc((n+1)/2)\n\n\nNote that MathWorld's definition starts with unity, not zero.   This task will be using the OEIS' version   (above).\n\n\n\n;An observation:\n:::::*   fusc(A) = fusc(B)\n\nwhere   '''A'''   is some non-negative integer expressed in binary,   and\nwhere   '''B'''   is the binary value of   '''A'''   reversed.\n\n\n\nFusc numbers are also known as:\n::*   fusc function   (named by Dijkstra, 1982)\n::*   Stern's Diatomic series   (although it starts with unity, not zero)\n::*   Stern-Brocot sequence   (although it starts with unity, not zero)\n\n\n\n;Task:\n::*   show the first   '''61'''   fusc numbers (starting at zero) in a horizontal format.\n::*   show the fusc number (and its index) whose length is greater than any previous fusc number length.\n::::*   (the length is the number of decimal digits when the fusc number is expressed in base ten.)\n::*   show all numbers with commas   (if appropriate).\n::*   show all output here.\n\n\n;Related task:\n::*   RosettaCode Stern-Brocot sequence\n\n\n\n;Also see:\n::*   the MathWorld entry:   Stern's Diatomic Series.\n::*   the OEIS      entry:   A2487.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nstatic class program\n{\n    static int n = 61;\n    static List<int> l = new List<int>() { 0, 1 };\n\n    static int fusc(int n)\n    {\n        if (n < l.Count) return l[n];\n        int f = (n & 1) == 0 ? l[n >> 1] : l[(n - 1) >> 1] + l[(n + 1) >> 1];\n        l.Add(f); return f;\n    }\n\n    static void Main(string[] args)\n    {\n        bool lst = true; int w = -1, c = 0, t;\n        string fs = \"{0,11:n0}  {1,-9:n0}\", res = \"\";\n        Console.WriteLine(\"First {0} numbers in the fusc sequence:\", n);\n        for (int i = 0; i < int.MaxValue; i++)\n        {\n            int f = fusc(i); if (lst)\n            {\n                if (i < 61) Console.Write(\"{0} \", f);\n                else\n                {\n                    lst = false;\n                    Console.WriteLine();\n                    Console.WriteLine(\"Points in the sequence where an item has more digits than any previous items:\");\n                    Console.WriteLine(fs, \"Index\\\\\", \"/Value\"); Console.WriteLine(res); res = \"\";\n                }\n            }\n            if ((t = f.ToString().Length) > w)\n            {\n                w = t; res += (res == \"\" ? \"\" : \"\\n\") + string.Format(fs, i, f);\n                if (!lst) { Console.WriteLine(res); res = \"\"; } if (++c > 5) break;\n            }\n        }\n        l.Clear();\n    }\n}"}
{"title": "Gapful numbers", "language": "C#", "task": "Numbers   (positive integers expressed in base ten)   that are (evenly) divisible by the number formed by the\nfirst and last digit are known as   '''gapful numbers'''.\n\n\n''Evenly divisible''   means divisible with   no   remainder.\n\n\nAll   one-   and two-digit   numbers have this property and are trivially excluded.   Only\nnumbers    >=  '''100'''   will be considered for this Rosetta Code task.\n\n\n;Example:\n'''187'''   is a   '''gapful'''   number because it is evenly divisible by the\nnumber   '''17'''   which is formed by the first and last decimal digits\nof    '''187'''. \n\n\nAbout   7.46%   of positive integers are   ''gapful''. \n\n\n;Task:\n:*   Generate and show all sets of numbers (below) on one line (horizontally) with a title,   here on this page\n:*   Show the first   '''30'''   gapful numbers\n:*   Show the first   '''15'''   gapful numbers    >=           '''1,000,000'''\n:*   Show the first   '''10'''   gapful numbers    >=                               '''1,000,000,000'''\n\n\n;Related tasks:\n:*   Harshad or Niven series.\n:*   palindromic gapful numbers.\n:*   largest number divisible by its digits.\n\n\n;Also see:\n:*   The OEIS entry:   A108343 gapful numbers.\n:*   numbersaplenty gapful numbers\n\n", "solution": "using System;\n\nnamespace GapfulNumbers\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            Console.WriteLine(\"The first 30 gapful numbers are: \");\n            /* Starting at 100, find 30 gapful numbers */\n            FindGap(100, 30);\n\n            Console.WriteLine(\"The first 15 gapful numbers > 1,000,000 are: \");\n            FindGap(1000000, 15);\n\n            Console.WriteLine(\"The first 10 gapful numbers > 1,000,000,000 are: \");\n            FindGap(1000000000, 10);\n\n            Console.Read();\n        }\n\n        public static int firstNum(int n)\n        {\n            /*Divide by ten until the leading digit remains.*/\n            while (n >= 10)\n            {\n                n /= 10;\n            }\n            return (n);\n        }\n\n        public static int lastNum(int n)\n        {\n            /*Modulo gives you the last digit. */\n            return (n % 10);\n        }\n\n        static void FindGap(int n, int gaps)\n        {\n            int count = 0;\n            while (count < gaps)\n            {\n\n                /* We have to convert our first and last digits to strings to concatenate.*/\n                string concat = firstNum(n).ToString() + lastNum(n).ToString();\n                /* And then convert our concatenated string back to an integer. */\n                int i = Convert.ToInt32(concat);\n\n                /* Modulo with our new integer and output the result. */\n                if (n % i == 0)\n                {\n                    Console.Write(n + \" \");\n                    count++;\n                    n++;\n                }\n                else\n                {\n                    n++;\n                    continue;\n                }\n            }\n        }\n    }\n}\n\n\n"}
{"title": "Gauss-Jordan matrix inversion", "language": "C sharp|C#", "task": "Invert matrix   '''A'''   using Gauss-Jordan method.\n\n'''A'''   being an   '''n''' x '''n'''   matrix.\n\n", "solution": "using System;\n\nnamespace Rosetta\n{\n    internal class Vector\n    {\n        private double[] b;\n        internal readonly int rows;\n\n        internal Vector(int rows)\n        {\n            this.rows = rows;\n            b = new double[rows];\n        }\n\n        internal Vector(double[] initArray)\n        {\n            b = (double[])initArray.Clone();\n            rows = b.Length;\n        }\n\n        internal Vector Clone()\n        {\n            Vector v = new Vector(b);\n            return v;\n        }\n\n        internal double this[int row]\n        {\n            get { return b[row]; }\n            set { b[row] = value; }\n        }\n\n        internal void SwapRows(int r1, int r2)\n        {\n            if (r1 == r2) return;\n            double tmp = b[r1];\n            b[r1] = b[r2];\n            b[r2] = tmp;\n        }\n\n        internal double norm(double[] weights)\n        {\n            double sum = 0;\n            for (int i = 0; i < rows; i++)\n            {\n                double d = b[i] * weights[i];\n                sum +=  d*d;\n            }\n            return Math.Sqrt(sum);\n        }\n\n        internal void print()\n        {\n            for (int i = 0; i < rows; i++)\n                Console.WriteLine(b[i]);\n            Console.WriteLine();\n        }\n\n        public static Vector operator-(Vector lhs, Vector rhs)\n        {\n            Vector v = new Vector(lhs.rows);\n            for (int i = 0; i < lhs.rows; i++)\n                v[i] = lhs[i] - rhs[i];\n            return v;\n        }\n    }\n\n    class Matrix\n    {\n        private double[] b;\n        internal readonly int rows, cols;\n\n        internal Matrix(int rows, int cols)\n        {\n            this.rows = rows;\n            this.cols = cols;\n            b = new double[rows * cols];            \n        }\n\n        internal Matrix(int size)\n        {\n            this.rows = size;\n            this.cols = size;\n            b = new double[rows * cols];\n            for (int i = 0; i < size; i++)\n                this[i, i] = 1;\n        }\n\n        internal Matrix(int rows, int cols, double[] initArray)\n        {\n            this.rows = rows;\n            this.cols = cols;\n            b = (double[])initArray.Clone();\n            if (b.Length != rows * cols) throw new Exception(\"bad init array\");\n        }\n\n        internal double this[int row, int col]\n        {\n            get { return b[row * cols + col]; }\n            set { b[row * cols + col] = value; }\n        }        \n        \n        public static Vector operator*(Matrix lhs, Vector rhs)\n        {\n            if (lhs.cols != rhs.rows) throw new Exception(\"I can't multiply matrix by vector\");\n            Vector v = new Vector(lhs.rows);\n            for (int i = 0; i < lhs.rows; i++)\n            {\n                double sum = 0;\n                for (int j = 0; j < rhs.rows; j++)\n                    sum += lhs[i,j]*rhs[j];\n                v[i] = sum;\n            }\n            return v;\n        }\n\n        internal void SwapRows(int r1, int r2)\n        {\n            if (r1 == r2) return;\n            int firstR1 = r1 * cols;\n            int firstR2 = r2 * cols;\n            for (int i = 0; i < cols; i++)\n            {\n                double tmp = b[firstR1 + i];\n                b[firstR1 + i] = b[firstR2 + i];\n                b[firstR2 + i] = tmp;\n            }\n        }\n\n        //with partial pivot\n        internal bool InvPartial()\n        {\n            const double Eps = 1e-12;\n            if (rows != cols) throw new Exception(\"rows != cols for Inv\");\n            Matrix M = new Matrix(rows); //unitary\n            for (int diag = 0; diag < rows; diag++)\n            {\n                int max_row = diag;\n                double max_val = Math.Abs(this[diag, diag]);\n                double d;\n                for (int row = diag + 1; row < rows; row++)\n                    if ((d = Math.Abs(this[row, diag])) > max_val)\n                    {\n                        max_row = row;\n                        max_val = d;\n                    }\n                if (max_val <= Eps) return false;\n                SwapRows(diag, max_row);\n                M.SwapRows(diag, max_row);\n                double invd = 1 / this[diag, diag];\n                for (int col = diag; col < cols; col++)\n                {\n                    this[diag, col] *= invd;\n                }\n                for (int col = 0; col < cols; col++)\n                {\n                    M[diag, col] *= invd;\n                }\n                for (int row = 0; row < rows; row++)\n                {\n                    d = this[row, diag];\n                    if (row != diag)\n                    {\n                        for (int col = diag; col < this.cols; col++)\n                        {\n                            this[row, col] -= d * this[diag, col];\n                        }\n                        for (int col = 0; col < this.cols; col++)\n                        {\n                            M[row, col] -= d * M[diag, col];\n                        }\n                    }\n                }\n            }\n            b = M.b;\n            return true;\n        }\n\n        internal void print()\n        {\n            for (int i = 0; i < rows; i++)\n            {\n                for (int j = 0; j < cols; j++)\n                    Console.Write(this[i,j].ToString()+\"  \");\n                Console.WriteLine();\n            }\n        }\n    }\n}\n"}
{"title": "Gaussian elimination", "language": "C sharp|C#", "task": "Solve   '''Ax=b'''   using Gaussian elimination then backwards substitution. \n\n'''A'''   being an   '''n''' by '''n'''   matrix. \n\nAlso,   '''x''' and '''b'''   are   '''n''' by '''1'''   vectors. \n\nTo improve accuracy, please use partial pivoting and scaling.\n\n\n;See also:\n:*   the Wikipedia entry:   Gaussian elimination\n\n", "solution": "using System;\n\nnamespace Rosetta\n{\n    internal class Vector\n    {\n        private double[] b;\n        internal readonly int rows;\n\n        internal Vector(int rows)\n        {\n            this.rows = rows;\n            b = new double[rows];\n        }\n\n        internal Vector(double[] initArray)\n        {\n            b = (double[])initArray.Clone();\n            rows = b.Length;\n        }\n\n        internal Vector Clone()\n        {\n            Vector v = new Vector(b);\n            return v;\n        }\n\n        internal double this[int row]\n        {\n            get { return b[row]; }\n            set { b[row] = value; }\n        }\n\n        internal void SwapRows(int r1, int r2)\n        {\n            if (r1 == r2) return;\n            double tmp = b[r1];\n            b[r1] = b[r2];\n            b[r2] = tmp;\n        }\n\n        internal double norm(double[] weights)\n        {\n            double sum = 0;\n            for (int i = 0; i < rows; i++)\n            {\n                double d = b[i] * weights[i];\n                sum +=  d*d;\n            }\n            return Math.Sqrt(sum);\n        }\n\n        internal void print()\n        {\n            for (int i = 0; i < rows; i++)\n                Console.WriteLine(b[i]);\n            Console.WriteLine();\n        }\n\n        public static Vector operator-(Vector lhs, Vector rhs)\n        {\n            Vector v = new Vector(lhs.rows);\n            for (int i = 0; i < lhs.rows; i++)\n                v[i] = lhs[i] - rhs[i];\n            return v;\n        }\n    }\n\n    class Matrix\n    {\n        private double[] b;\n        internal readonly int rows, cols;\n\n        internal Matrix(int rows, int cols)\n        {\n            this.rows = rows;\n            this.cols = cols;\n            b = new double[rows * cols];            \n        }\n\n        internal Matrix(int size)\n        {\n            this.rows = size;\n            this.cols = size;\n            b = new double[rows * cols];\n            for (int i = 0; i < size; i++)\n                this[i, i] = 1;\n        }\n\n        internal Matrix(int rows, int cols, double[] initArray)\n        {\n            this.rows = rows;\n            this.cols = cols;\n            b = (double[])initArray.Clone();\n            if (b.Length != rows * cols) throw new Exception(\"bad init array\");\n        }\n\n        internal double this[int row, int col]\n        {\n            get { return b[row * cols + col]; }\n            set { b[row * cols + col] = value; }\n        }        \n        \n        public static Vector operator*(Matrix lhs, Vector rhs)\n        {\n            if (lhs.cols != rhs.rows) throw new Exception(\"I can't multiply matrix by vector\");\n            Vector v = new Vector(lhs.rows);\n            for (int i = 0; i < lhs.rows; i++)\n            {\n                double sum = 0;\n                for (int j = 0; j < rhs.rows; j++)\n                    sum += lhs[i,j]*rhs[j];\n                v[i] = sum;\n            }\n            return v;\n        }\n\n        internal void SwapRows(int r1, int r2)\n        {\n            if (r1 == r2) return;\n            int firstR1 = r1 * cols;\n            int firstR2 = r2 * cols;\n            for (int i = 0; i < cols; i++)\n            {\n                double tmp = b[firstR1 + i];\n                b[firstR1 + i] = b[firstR2 + i];\n                b[firstR2 + i] = tmp;\n            }\n        }\n\n        //with partial pivot\n        internal void ElimPartial(Vector B)\n        {\n            for (int diag = 0; diag < rows; diag++)\n            {\n                int max_row = diag;\n                double max_val = Math.Abs(this[diag, diag]);\n                double d;\n                for (int row = diag + 1; row < rows; row++)\n                    if ((d = Math.Abs(this[row, diag])) > max_val)\n                    {\n                        max_row = row;\n                        max_val = d;\n                    }\n                SwapRows(diag, max_row);\n                B.SwapRows(diag, max_row);\n                double invd = 1 / this[diag, diag];\n                for (int col = diag; col < cols; col++)\n                    this[diag, col] *= invd;\n                B[diag] *= invd;\n                for (int row = 0; row < rows; row++)\n                {\n                    d = this[row, diag];\n                    if (row != diag)\n                    {\n                        for (int col = diag; col < cols; col++)\n                            this[row, col] -= d * this[diag, col];\n                        B[row] -= d * B[diag];\n                    }\n                }\n            }\n        }\n        \n        internal void print()\n        {\n            for (int i = 0; i < rows; i++)\n            {\n                for (int j = 0; j < cols; j++)\n                    Console.Write(this[i,j].ToString()+\"  \");\n                Console.WriteLine();\n            }\n        }\n    }\n}\n"}
{"title": "Generator/Exponential", "language": "C sharp", "task": "A generator is an executable entity (like a function or procedure) that contains code that yields a sequence of values, one at a time, so that each time you call the generator, the next value in the sequence is provided.\n \nGenerators are often built on top of coroutines or objects so that the internal state of the object is handled \"naturally\". \n\nGenerators are often used in situations where a sequence is potentially infinite, and where it is possible to construct the next value of the sequence with only minimal state.\n\n\n;Task:\n* Create a function that returns a generation of the m'th powers of the positive integers starting from zero, in order, and without obvious or simple upper limit. (Any upper limit to the generator should not be stated in the source but should be down to factors such as the languages natural integer size limit or computational time/size).\n* Use it to create a generator of:\n:::*   Squares.\n:::*   Cubes. \n* Create a new generator that filters all cubes from the generator of squares.\n* Drop the first 20 values from this last generator of filtered results, and then show the next 10 values.\n\n\nNote that this task ''requires'' the use of generators in the calculation of the result.\n\n\n;Also see:\n* Generator\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nstatic class Program {\n    static void Main() {\n        Func<int, IEnumerable<int>> ms = m => Infinite().Select(i => (int)Math.Pow(i, m));\n        var squares = ms(2);\n        var cubes = ms(3);\n        var filtered = squares.Where(square => cubes.First(cube => cube >= square) != square);\n        var final = filtered.Skip(20).Take(10);\n        foreach (var i in final) Console.WriteLine(i);\n    }\n\n    static IEnumerable<int> Infinite() {\n        var i = 0;\n        while (true) yield return i++;\n    }\n}"}
{"title": "Get system command output", "language": "C sharp|C#", "task": "Task\nExecute a system command and get its output into the program. The output may be stored in any kind of collection (array, list, etc.). \n\n;Related task\n*  Execute a system command\n\n", "solution": "using System;\n\nnamespace GetSystemCommandOutput {\n    class Program {\n        static void Main(string[] args) {\n            System.Diagnostics.Process process = new System.Diagnostics.Process();\n            System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();\n            startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;\n            startInfo.FileName = \"cmd.exe\";\n            startInfo.Arguments = \"/c echo Hello World\";\n            startInfo.RedirectStandardOutput = true;\n            startInfo.UseShellExecute = false;\n            process.StartInfo = startInfo;\n            process.Start();\n\n            string output = process.StandardOutput.ReadToEnd();\n            Console.WriteLine(\"Output is {0}\", output);\n        }\n    }\n}"}
{"title": "Globally replace text in several files", "language": "C sharp", "task": "Replace every occurring instance of a piece of text in a group of text files with another one. \n\n\nFor this task we want to replace the text   \"'''Goodbye London!'''\"   with   \"'''Hello New York!'''\"   for a list of files.\n\n", "solution": "using System.Collections.Generic;\nusing System.IO;\n\nclass Program {\n    static void Main() {\n        var files = new List<string> {\n            \"test1.txt\",\n            \"test2.txt\"\n        };\n        foreach (string file in files) {\n            File.WriteAllText(file, File.ReadAllText(file).Replace(\"Goodbye London!\", \"Hello New York!\"));\n        }\n    }\n}\n"}
{"title": "Gray code", "language": "C sharp", "task": "Karnaugh maps in order from left to right or top to bottom.\nCreate functions to encode a number to and decode a number from Gray code. \n\nDisplay the normal binary representations, Gray code representations, and decoded Gray code values for all 5-bit binary numbers (0-31 inclusive, leading 0's not necessary).\n\nThere are many possible Gray codes. The following encodes what is called \"binary reflected Gray code.\"\n\nEncoding (MSB is bit 0, b is binary, g is Gray code):\n\nif b[i-1] = 1\n   g[i] = not b[i]\nelse\n   g[i] = b[i]\n\nOr:\n\ng = b xor (b logically right shifted 1 time)\n\nDecoding (MSB is bit 0, b is binary, g is Gray code):\n\nb[0] = g[0]\n\nfor other bits:\nb[i] = g[i] xor b[i-1]\n\n;Reference\n* Converting Between Gray and Binary Codes. It includes step-by-step animations.\n\n", "solution": "using System;\n\npublic class Gray {\n    public static ulong grayEncode(ulong n) {\n        return n^(n>>1);\n    }\n\n    public static ulong grayDecode(ulong n) {\n        ulong i=1<<8*64-2; //long is 64-bit\n        ulong p, b=p=n&i;\n\n        while((i>>=1)>0)\n            b|=p=n&i^p>>1;\n        return b;\n    }\n\n    public static void Main(string[] args) {\n        Console.WriteLine(\"Number\\tBinary\\tGray\\tDecoded\");\n        for(ulong i=0;i<32;i++) {\n            Console.WriteLine(string.Format(\"{0}\\t{1}\\t{2}\\t{3}\", i, Convert.ToString((long)i, 2), Convert.ToString((long)grayEncode(i), 2), grayDecode(grayEncode(i))));\n        }\n    }\n}"}
{"title": "Greatest subsequential sum", "language": "C sharp|C#", "task": "Given a sequence of integers, find a continuous subsequence which maximizes the sum of its elements, that is, the elements of no other single subsequence add up to a value larger than this one. \n\n\nAn empty subsequence is considered to have the sum of   '''0''';   thus if all elements are negative, the result must be the empty sequence.\n\n", "solution": "using System;\n\nnamespace Tests_With_Framework_4\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            int[] integers = { -1, -2, 3, 5, 6, -2, -1, 4, -4, 2, -1 }; int length = integers.Length;\n            int maxsum, beginmax, endmax, sum; maxsum = beginmax = sum = 0; endmax = -1;\n\n            for (int i = 0; i < length; i++)\n            {\n                sum = 0;\n                for (int k = i; k < length; k++)\n                {\n                    sum += integers[k];\n                    if (sum > maxsum)\n                    {\n                        maxsum = sum;\n                        beginmax = i;\n                        endmax = k;\n                    }\n                }\n            }\n\n            for (int i = beginmax; i <= endmax; i++)\n                Console.WriteLine(integers[i]);\n\n            Console.ReadKey();\n        }\n    }\n}"}
{"title": "Greedy algorithm for Egyptian fractions", "language": "C sharp|C# from Visual Basic .NET", "task": "An   Egyptian fraction   is the sum of distinct unit fractions such as: \n\n::::   \\tfrac{1}{2} + \\tfrac{1}{3} + \\tfrac{1}{16} \\,(= \\tfrac{43}{48}) \n\nEach fraction in the expression has a numerator equal to   '''1'''   (unity)   and a denominator that is a positive integer,   and all the denominators are distinct   (i.e., no repetitions).  \n\nFibonacci's   Greedy algorithm for Egyptian fractions   expands the fraction     \\tfrac{x}{y}     to be represented by repeatedly performing the replacement\n\n::::   \\frac{x}{y} = \\frac{1}{\\lceil y/x\\rceil} + \\frac{(-y)\\!\\!\\!\\!\\mod x}{y\\lceil y/x\\rceil}  \n\n\n(simplifying the 2nd term in this replacement as necessary, and where     \\lceil x \\rceil     is the   ''ceiling''   function).\n\n\n\nFor this task,   Proper and improper fractions   must be able to be expressed.\n\n\nProper  fractions   are of the form    \\tfrac{a}{b}    where    a    and    b    are positive integers, such that    a < b,     and \n\nimproper fractions are of the form    \\tfrac{a}{b}    where    a    and    b    are positive integers, such that    ''a'' >= ''b''. \n\n\n(See the REXX programming example to view one method of expressing the whole number part of an improper fraction.)\n\nFor improper fractions, the integer part of any improper fraction should be first isolated and shown preceding the Egyptian unit fractions, and be surrounded by square brackets [''n''].\n\n\n;Task requirements:\n*   show the Egyptian fractions for:  \\tfrac{43}{48}  and  \\tfrac{5}{121}  and  \\tfrac{2014}{59} \n*   for all proper fractions,    \\tfrac{a}{b}    where    a    and    b    are positive one-or two-digit (decimal) integers, find and show an Egyptian fraction that has:\n::*   the largest number of terms,\n::*   the largest denominator.\n*   for all one-, two-, and three-digit integers,   find and show (as above).     {extra credit}\n\n\n;Also see:\n*   Wolfram MathWorld(tm) entry: Egyptian fraction\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Numerics;\nusing System.Text;\nusing System.Threading.Tasks;\n\nnamespace EgyptianFractions {\n    class Program {\n        class Rational : IComparable<Rational>, IComparable<int> {\n            public BigInteger Num { get; }\n            public BigInteger Den { get; }\n\n            public Rational(BigInteger n, BigInteger d) {\n                var c = Gcd(n, d);\n                Num = n / c;\n                Den = d / c;\n                if (Den < 0) {\n                    Num = -Num;\n                    Den = -Den;\n                }\n            }\n\n            public Rational(BigInteger n) {\n                Num = n;\n                Den = 1;\n            }\n\n            public override string ToString() {\n                if (Den == 1) {\n                    return Num.ToString();\n                } else {\n                    return string.Format(\"{0}/{1}\", Num, Den);\n                }\n            }\n\n            public Rational Add(Rational rhs) {\n                return new Rational(Num * rhs.Den + rhs.Num * Den, Den * rhs.Den);\n            }\n\n            public Rational Sub(Rational rhs) {\n                return new Rational(Num * rhs.Den - rhs.Num * Den, Den * rhs.Den);\n            }\n\n            public int CompareTo(Rational rhs) {\n                var ad = Num * rhs.Den;\n                var bc = Den * rhs.Num;\n                return ad.CompareTo(bc);\n            }\n\n            public int CompareTo(int rhs) {\n                var ad = Num * rhs;\n                var bc = Den * rhs;\n                return ad.CompareTo(bc);\n            }\n        }\n\n        static BigInteger Gcd(BigInteger a, BigInteger b) {\n            if (b == 0) {\n                if (a < 0) {\n                    return -a;\n                } else {\n                    return a;\n                }\n            } else {\n                return Gcd(b, a % b);\n            }\n        }\n\n        static List<Rational> Egyptian(Rational r) {\n            List<Rational> result = new List<Rational>();\n\n            if (r.CompareTo(1) >= 0) {\n                if (r.Den == 1) {\n                    result.Add(r);\n                    result.Add(new Rational(0));\n                    return result;\n                }\n                result.Add(new Rational(r.Num / r.Den));\n                r = r.Sub(result[0]);\n            }\n\n            BigInteger modFunc(BigInteger m, BigInteger n) {\n                return ((m % n) + n) % n;\n            }\n\n            while (r.Num != 1) {\n                var q = (r.Den + r.Num - 1) / r.Num;\n                result.Add(new Rational(1, q));\n                r = new Rational(modFunc(-r.Den, r.Num), r.Den * q);\n            }\n\n            result.Add(r);\n            return result;\n        }\n\n        static string FormatList<T>(IEnumerable<T> col) {\n            StringBuilder sb = new StringBuilder();\n            var iter = col.GetEnumerator();\n\n            sb.Append('[');\n            if (iter.MoveNext()) {\n                sb.Append(iter.Current);\n            }\n            while (iter.MoveNext()) {\n                sb.AppendFormat(\", {0}\", iter.Current);\n            }\n            sb.Append(']');\n\n            return sb.ToString();\n        }\n\n        static void Main() {\n            List<Rational> rs = new List<Rational> {\n                new Rational(43, 48),\n                new Rational(5, 121),\n                new Rational(2014, 59)\n            };\n            foreach (var r in rs) {\n                Console.WriteLine(\"{0} => {1}\", r, FormatList(Egyptian(r)));\n            }\n\n            var lenMax = Tuple.Create(0UL, new Rational(0));\n            var denomMax = Tuple.Create(BigInteger.Zero, new Rational(0));\n\n            var query = (from i in Enumerable.Range(1, 100)\n                         from j in Enumerable.Range(1, 100)\n                         select new Rational(i, j))\n                         .Distinct()\n                         .ToList();\n            foreach (var r in query) {\n                var e = Egyptian(r);\n                ulong eLen = (ulong) e.Count;\n                var eDenom = e.Last().Den;\n                if (eLen > lenMax.Item1) {\n                    lenMax = Tuple.Create(eLen, r);\n                }\n                if (eDenom > denomMax.Item1) {\n                    denomMax = Tuple.Create(eDenom, r);\n                }\n            }\n\n            Console.WriteLine(\"Term max is {0} with {1} terms\", lenMax.Item2, lenMax.Item1);\n            var dStr = denomMax.Item1.ToString();\n            Console.WriteLine(\"Denominator max is {0} with {1} digits {2}...{3}\", denomMax.Item2, dStr.Length, dStr.Substring(0, 5), dStr.Substring(dStr.Length - 5, 5));\n        }\n    }\n}"}
{"title": "Hailstone sequence", "language": "C sharp|C#", "task": "The Hailstone sequence of numbers can be generated from a starting positive integer,   n   by:\n*   If   n   is     '''1'''     then the sequence ends.\n*   If   n   is   '''even''' then the next   n   of the sequence    = n/2 \n*   If   n   is   '''odd'''    then the next   n   of the sequence    = (3 * n) + 1 \n\n\nThe (unproven) Collatz conjecture is that the hailstone sequence for any starting number always terminates.\n\n\nThis sequence was named by Lothar Collatz in 1937   (or possibly in 1939),   and is also known as (the):\n:::*   hailstone sequence,   hailstone numbers\n:::*   3x + 2 mapping,   3n + 1 problem\n:::*   Collatz sequence\n:::*   Hasse's algorithm\n:::*   Kakutani's problem\n:::*   Syracuse algorithm,   Syracuse problem\n:::*   Thwaites conjecture \n:::*   Ulam's problem\n\n\nThe hailstone sequence is also known as   ''hailstone numbers''   (because the values are usually subject to multiple descents and ascents like hailstones in a cloud).\n\n\n;Task:\n# Create a routine to generate the hailstone sequence for a number.\n# Use the routine to show that the hailstone sequence for the number 27 has 112 elements starting with 27, 82, 41, 124 and ending with 8, 4, 2, 1\n# Show the number less than 100,000 which has the longest hailstone sequence together with that sequence's length.    (But don't show the actual sequence!)\n\n\n;See also:\n*   xkcd (humourous).\n*   The Notorious Collatz conjecture Terence Tao, UCLA (Presentation, pdf).\n*   The Simplest Math Problem No One Can Solve Veritasium (video, sponsored).\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Hailstone\n{\n    class Program\n    {\n        public static List<int> hs(int n,List<int> seq)\n        {\n            List<int> sequence = seq;\n            sequence.Add(n);\n            if (n == 1)\n            {\n                return sequence;\n            }else{\n                int newn = (n % 2 == 0) ? n / 2 : (3 * n) + 1;\n                return hs(newn, sequence);\n            }                        \n        }\n\n        static void Main(string[] args)\n        {\n            int n = 27;\n            List<int> sequence = hs(n,new List<int>());\n            Console.WriteLine(sequence.Count + \" Elements\");\n            List<int> start = sequence.GetRange(0, 4);\n            List<int> end = sequence.GetRange(sequence.Count - 4, 4);\n            Console.WriteLine(\"Starting with : \" + string.Join(\",\", start) + \" and ending with : \" + string.Join(\",\", end));            \n            int number = 0, longest = 0;            \n            for (int i = 1; i < 100000; i++)\n            {\n                int count = (hs(i, new List<int>())).Count;\n                if (count > longest)\n                {\n                    longest = count;\n                    number = i;\n                }\n            }\n            Console.WriteLine(\"Number < 100000 with longest Hailstone seq.: \" + number + \" with length of \" + longest);\n       }\n    }\n}"}
{"title": "Harshad or Niven series", "language": "C sharp|C#", "task": "The Harshad or Niven numbers are positive integers >= 1 that are divisible by the sum of their digits. \n\nFor example,   '''42'''   is a Harshad number as   '''42'''   is divisible by   ('''4''' + '''2''')   without remainder.\n\nAssume that the series is defined as the numbers in increasing order.\n\n\n;Task:\nThe task is to create a function/method/procedure to generate successive members of the Harshad sequence. \n\nUse it to:\n::*   list the first '''20''' members of the sequence,   and\n::*   list the first Harshad number greater than '''1000'''.\n\n\nShow your output here.\n\n\n;Related task\n:*   Increasing gaps between consecutive Niven numbers\n\n\n;See also\n*    OEIS: A005349\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace Harshad\n{\n    class Program\n    {\n        public static bool IsHarshad(int n)\n        {\n            char[] inputChars = n.ToString().ToCharArray();\n            IList<byte> digits = new List<byte>();\n\n            foreach (char digit in inputChars)\n            {\n                digits.Add((byte)Char.GetNumericValue(digit));\n            }\n\n            if (n < 1)\n            {\n                return false;\n            }\n\n            int sum = 0;\n\n            foreach (byte digit in digits)\n            {\n                sum += digit;\n            }\n\n            return n % sum == 0;\n        }\n\n        static void Main(string[] args)\n        {\n            int i = 1;\n            int count = 0;\n\n            while (true)\n            {\n                if (IsHarshad(i))\n                {\n                    count++;\n\n                    if (count <= 20)\n                    {\n                        Console.Write(string.Format(\"{0} \", i));\n                    }\n                    else if (i > 1000)\n                    {\n                        Console.Write(string.Format(\"{0} \", i));\n                        break;\n                    }\n                }\n\n                i++;\n            }\n\n            Console.ReadKey();\n        }\n    }\n}\n"}
{"title": "Hash join", "language": "C sharp", "task": "{| class=\"wikitable\"\n|-\n! Input\n! Output\n|-\n|\n\n{| style=\"border:none; border-collapse:collapse;\"\n|-\n| style=\"border:none\" | ''A'' = \n| style=\"border:none\" |\n\n{| class=\"wikitable\"\n|-\n! Age !! Name\n|-\n| 27 || Jonah\n|-\n| 18 || Alan\n|-\n| 28 || Glory\n|-\n| 18 || Popeye\n|-\n| 28 || Alan\n|}\n\n| style=\"border:none; padding-left:1.5em;\" rowspan=\"2\" |\n| style=\"border:none\" | ''B'' = \n| style=\"border:none\" |\n\n{| class=\"wikitable\"\n|-\n! Character !! Nemesis\n|-\n| Jonah || Whales\n|-\n| Jonah || Spiders\n|-\n| Alan || Ghosts\n|-\n| Alan || Zombies\n|-\n| Glory || Buffy\n|}\n\n|-\n| style=\"border:none\" | ''jA'' =\n| style=\"border:none\" | Name (i.e. column 1)\n\n| style=\"border:none\" | ''jB'' =\n| style=\"border:none\" | Character (i.e. column 0)\n|}\n\n|\n\n{| class=\"wikitable\" style=\"margin-left:1em\"\n|-\n! A.Age !! A.Name !! B.Character !! B.Nemesis\n|-\n| 27 || Jonah || Jonah || Whales\n|-\n| 27 || Jonah || Jonah || Spiders\n|-\n| 18 || Alan || Alan || Ghosts\n|-\n| 18 || Alan || Alan || Zombies\n|-\n| 28 || Glory || Glory || Buffy\n|-\n| 28 || Alan || Alan || Ghosts\n|-\n| 28 || Alan || Alan || Zombies\n|}\n\n|}\n\nThe order of the rows in the output table is not significant.\nIf you're using numerically indexed arrays to represent table rows (rather than referring to columns by name), you could represent the output rows in the form [[27, \"Jonah\"], [\"Jonah\", \"Whales\"]].\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace HashJoin\n{\n    public class AgeName\n    {\n        public AgeName(byte age, string name)\n        {\n            Age = age;\n            Name = name;\n        }\n        public byte Age { get; private set; }\n        public string Name { get; private set; }\n    }\n\n    public class NameNemesis\n    {\n        public NameNemesis(string name, string nemesis)\n        {\n            Name = name;\n            Nemesis = nemesis;\n        }\n        public string Name { get; private set; }\n        public string Nemesis { get; private set; }\n    }\n\n    public class DataContext\n    {\n        public DataContext()\n        {\n            AgeName = new List<AgeName>();\n            NameNemesis = new List<NameNemesis>();\n        }\n        public List<AgeName> AgeName { get; set; }\n        public List<NameNemesis> NameNemesis { get; set; }\n    }\n\n    public class AgeNameNemesis\n    {\n        public AgeNameNemesis(byte age, string name, string nemesis)\n        {\n            Age = age;\n            Name = name;\n            Nemesis = nemesis;\n        }\n        public byte Age { get; private set; }\n        public string Name { get; private set; }\n        public string Nemesis { get; private set; }\n    }\n\n    class Program\n    {\n        public static void Main()\n        {\n            var data = GetData();\n            var result = ExecuteHashJoin(data);\n            WriteResultToConsole(result);\n        }\n\n        private static void WriteResultToConsole(List<AgeNameNemesis> result)\n        {\n            result.ForEach(ageNameNemesis => Console.WriteLine(\"Age: {0}, Name: {1}, Nemesis: {2}\",\n                ageNameNemesis.Age, ageNameNemesis.Name, ageNameNemesis.Nemesis));\n        }\n\n        private static List<AgeNameNemesis> ExecuteHashJoin(DataContext data)\n        {\n            return (data.AgeName.Join(data.NameNemesis, \n                ageName => ageName.Name, nameNemesis => nameNemesis.Name,\n                (ageName, nameNemesis) => new AgeNameNemesis(ageName.Age, ageName.Name, nameNemesis.Nemesis)))\n                .ToList();\n        }\n\n        private static DataContext GetData()\n        {\n            var context = new DataContext();\n\n            context.AgeName.AddRange(new [] {\n                    new AgeName(27, \"Jonah\"), \n                    new AgeName(18, \"Alan\"), \n                    new AgeName(28, \"Glory\"), \n                    new AgeName(18, \"Popeye\"), \n                    new AgeName(28, \"Alan\")\n                });\n\n            context.NameNemesis.AddRange(new[]\n            {\n                new NameNemesis(\"Jonah\", \"Whales\"),\n                new NameNemesis(\"Jonah\", \"Spiders\"),\n                new NameNemesis(\"Alan\", \"Ghosts\"),\n                new NameNemesis(\"Alan\", \"Zombies\"),\n                new NameNemesis(\"Glory\", \"Buffy\")\n            });\n\n            return context;\n        }\n    }\n}"}
{"title": "Haversine formula", "language": "c sharp|C# from Groovy", "task": "{{Wikipedia}}\n\n\nThe '''haversine formula''' is an equation important in navigation, giving great-circle distances between two points on a sphere from their longitudes and latitudes. \n\nIt is a special case of a more general formula  in spherical trigonometry, the '''law of haversines''', relating the sides and angles of spherical \"triangles\".\n\n\n;Task:\nImplement a great-circle distance function, or use a library function, \nto show the great-circle distance between:\n* Nashville International Airport (BNA)   in Nashville, TN, USA,   which is: \n    '''N''' 36deg7.2',   '''W''' 86deg40.2'     (36.12,   -86.67)           -and-\n* Los Angeles International Airport (LAX)  in Los Angeles, CA, USA,   which is:\n    '''N''' 33deg56.4',  '''W''' 118deg24.0'    (33.94,  -118.40) \n\n\nUser Kaimbridge clarified on the Talk page:\n\n -- 6371.0 km is the authalic radius based on/extracted from surface area;\n -- 6372.8 km is an approximation of the radius of the average circumference\n    (i.e., the average great-elliptic or great-circle radius), where the\n     boundaries are the meridian (6367.45 km) and the equator (6378.14 km).\n\nUsing either of these values results, of course, in differing distances:\n\n 6371.0 km -> 2886.44444283798329974715782394574671655 km;\n 6372.8 km -> 2887.25995060711033944886005029688505340 km;\n (results extended for accuracy check:  Given that the radii are only\n  approximations anyways, .01'  1.0621333 km and .001\"  .00177 km,\n  practical precision required is certainly no greater than about\n  .0000001----i.e., .1 mm!)\n\nAs distances are segments of great circles/circumferences, it is\nrecommended that the latter value (r = 6372.8 km) be used (which\nmost of the given solutions have already adopted, anyways). \n\n\nMost of the examples below adopted Kaimbridge's recommended value of\n6372.8 km for the earth radius.  However, the derivation of this\nellipsoidal quadratic mean radius\nis wrong (the averaging over azimuth is biased).  When applying these\nexamples in real applications, it is better to use the\nmean earth radius,\n6371 km.  This value is recommended by the International Union of\nGeodesy and Geophysics and it minimizes the RMS relative error between the\ngreat circle and geodesic distance.\n\n", "solution": "public static class Haversine {\n  public static double calculate(double lat1, double lon1, double lat2, double lon2) {\n    var R = 6372.8; // In kilometers\n    var dLat = toRadians(lat2 - lat1);\n    var dLon = toRadians(lon2 - lon1);\n    lat1 = toRadians(lat1);\n    lat2 = toRadians(lat2);\n   \n    var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) + Math.Sin(dLon / 2) * Math.Sin(dLon / 2) * Math.Cos(lat1) * Math.Cos(lat2);\n    var c = 2 * Math.Asin(Math.Sqrt(a));\n    return R * 2 * Math.Asin(Math.Sqrt(a));\n  }\n  \n  public static double toRadians(double angle) {\n    return Math.PI * angle / 180.0;\n  }\n}\n\nvoid Main() {\n  Console.WriteLine(String.Format(\"The distance between coordinates {0},{1} and {2},{3} is: {4}\", 36.12, -86.67, 33.94, -118.40, Haversine.calculate(36.12, -86.67, 33.94, -118.40)));\n}\n\n// Returns: The distance between coordinates 36.12,-86.67 and 33.94,-118.4 is: 2887.25995060711\n"}
{"title": "Hello world/Line printer", "language": "C sharp", "task": "Cause a line printer attached to the computer to print a line containing the message:    Hello World! \n\n\n;Note:\nA line printer is not the same as standard output. \n\nA   line printer   was an older-style printer which prints one line at a time to a continuous ream of paper. \n\nWith some systems, a line printer can be any device attached to an appropriate port (such as a parallel port).\n\n", "solution": "[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]\npublic class DOCINFOA\n{\n    [MarshalAs(UnmanagedType.LPStr)]\n    public string pDocName;\n    [MarshalAs(UnmanagedType.LPStr)]\n    public string pOutputFile;\n    [MarshalAs(UnmanagedType.LPStr)]\n    public string pDataType;\n}\n\n[DllImport(\"winspool.Drv\", EntryPoint = \"OpenPrinterA\", CharSet = CharSet.Ansi, ExactSpelling = true)]\npublic static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);\n\n[DllImport(\"winspool.Drv\", EntryPoint = \"StartDocPrinterA\", CharSet = CharSet.Ansi, ExactSpelling = true)]\npublic static extern bool StartDocPrinter(IntPtr hPrinter, int level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);\n\n[DllImport(\"winspool.Drv\", EntryPoint = \"StartPagePrinter\", CharSet = CharSet.Ansi, ExactSpelling = true)]\npublic static extern bool StartPagePrinter(IntPtr hPrinter);\n\n[DllImport(\"winspool.Drv\", EntryPoint = \"EndPagePrinter\", CharSet = CharSet.Ansi, ExactSpelling = true)]\npublic static extern bool EndPagePrinter(IntPtr hPrinter);\n\n[DllImport(\"winspool.Drv\", EntryPoint = \"EndDocPrinter\", CharSet = CharSet.Ansi, ExactSpelling = true)]\npublic static extern bool EndDocPrinter(IntPtr hPrinter);\n\n[DllImport(\"winspool.Drv\", EntryPoint = \"ClosePrinter\", CharSet = CharSet.Ansi, ExactSpelling = true)]\npublic static extern bool ClosePrinter(IntPtr hPrinter);\n\n[DllImport(\"winspool.Drv\", EntryPoint = \"WritePrinter\", CharSet = CharSet.Ansi, ExactSpelling = true)]\npublic static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, out Int32 dwWritten);\n\npublic void HelloWorld()\n{\n    IntPtr hPrinter;\n    bool openSuccessful = OpenPrinter(\"My Printer\", out hPrinter, IntPtr.Zero);\n    if (openSuccessful)\n    {\n        DOCINFOA docInfo = new DOCINFOA();\n        docInfo.pDocName = \"Hello World Example\";\n        docInfo.pOutputFile = null;\n        docInfo.pDataType = \"RAW\";\n\n        if (StartDocPrinter(hPrinter, 1, docInfo))\n        {\n            StartPagePrinter(hPrinter);\n\n            const string helloWorld = \"Hello World!\";\n            IntPtr buf = Marshal.StringToCoTaskMemAnsi(helloWorld);\n\n            int bytesWritten;\n            WritePrinter(hPrinter, buf, helloWorld.Length, out bytesWritten);\n\n            Marshal.FreeCoTaskMem(buf);\n        }\n        if (EndPagePrinter(hPrinter))\n            if (EndDocPrinter(hPrinter))\n                ClosePrinter(hPrinter);\n    }\n}"}
{"title": "Hello world/Newbie", "language": "C sharp|C#", "task": "Guide a new user of a language through the steps necessary \nto install the programming language and selection of a text editor if needed, \nto run the languages' example in the [[Hello world/Text]] task.\n* Assume the language-newbie is a programmer in another language.\n* Assume the language-newbie is competent in installing software for the platform.\n* Assume the language-newbie can use one simple text editor for the OS/platform, (but that may not necessarily be a particular one if the installation needs a particular editor).\n* Refer to, (and link to), already existing documentation as much as possible (but provide a summary here).\n* Remember to state where to view the output.\n* If particular IDE's or editors are required that are not standard, then point to/explain their installation too.\n\n\n;Note:\n* If it is more natural for a language to give output via a GUI or to a file etc, then use that method of output rather than as text to a terminal/command-line, but remember to give instructions on how to view the output generated.\n* You may use sub-headings if giving instructions for multiple platforms.\n\n", "solution": "C# is an ECMA-standardized language with open-source implementations, though development of the language is dominated by Microsoft.  C# compilers and IDEs are available on most operating systems.\n\n===C# on Windows===\n\nDownload the [https://www.visualstudio.com/vs/community/ Visual Studio Community Edition], which is free for personal use.  This is a standard Windows click-through installer.\n\nOnce installed (and after a restart), open Visual Studio.\n\nClick on \"New Project...\" or do File > New > Project.\n\nSelect \"Console Application.\"  Make sure Visual C# / Windows is selected in the left pane (because Visual Studio handles multiple languages and platforms).\n\nType a name for your application in the \"Name\" field.\n\nClick OK.\n\nEnter the Hello World code from the Hello World task into Program.cs.\n\nPress the \"Start\" button or hit F5 to compile and run.\n\n===C# on iOS===\n\nThe [http://continuous.codes/ Continuous] App allows one to write, compile, and run C# code on an iOS device (iPad Pro recommended).\n\n===C# on Linux===\n\n====Mono====\n\nMono is the oldest effort to bring C# to Linux.\n\nInstall the mono-complete package.  Installation instructions are [http://www.mono-project.com/docs/getting-started/install/linux/ here].\n\nUse the text editor or IDE of your choice to enter the Hello World program, saving it as Hello.cs.\n\nTo compile:\n\n$ mcs hello.cs\n\nTo run:\n\n$ ./hello.exe\n\n====.NET Core====\n\n.NET Core is Microsoft's open-source implementation of C# and also part of the .NET libraries.\n\nMicrosoft's [https://www.microsoft.com/net/core#linuxredhat installation instructions for Linux] walk through installing .NET Core on a Linux system and also compiling and running a simple \"Hello, World!\" console application.\n\nIt does not come with an IDE, but consider [https://code.visualstudio.com/ Visual Studio Code.]\n\n===C# on macOS===\n\n====Xamarin Studio====\n\nXamarin Studio is an IDE combined with Mono as well as cross-platform development tools.  [https://developer.xamarin.com/guides/cross-platform/xamarin-studio/ Installation instructions are here.]\n\n====.NET Core====\n\n.NET Core is Microsoft's open-source implementation of C# and also part of the .NET libraries.\n\nMicrosoft's [https://www.microsoft.com/net/core#macos installation instructions for macOS] walk through installing .NET Core on macOS and also compiling and running a simple \"Hello, World!\" console application.\n\nIt does not come with an IDE, but consider [https://code.visualstudio.com/ Visual Studio Code.]\n\n"}
{"title": "Here document", "language": "C sharp", "task": "A   ''here document''    (or \"heredoc\")   is a way of specifying a text block, preserving the line breaks, indentation and other whitespace within the text. \n\nDepending on the language being used, a   ''here document''   is constructed using a command followed by \"<<\" (or some other symbol) followed by a token string. \n\nThe text block will then start on the next line, and will be followed by the chosen token at the beginning of the following line, which is used to mark the end of the text block.\n\n\n;Task:\nDemonstrate the use of   ''here documents''   within the language.\n\n;Related task:\n*   [[Documentation]]\n\n", "solution": "using System;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        Console.Write(@\"\nmultiline\nstrings are easy\nto put together\nin C#\");\n    }\n}"}
{"title": "Heronian triangles", "language": "C sharp|C#", "task": "Hero's formula for the area of a triangle given the length of its three sides    ''a'',   ''b'',   and   ''c''   is given by:\n\n:::: A = \\sqrt{s(s-a)(s-b)(s-c)},\n\nwhere   ''s''   is half the perimeter of the triangle; that is,\n\n:::: s=\\frac{a+b+c}{2}.\n\n'''Heronian triangles'''\nare triangles whose sides ''and area'' are all integers.\n: An example is the triangle with sides   '''3, 4, 5'''   whose area is   '''6'''   (and whose perimeter is   '''12'''). \n\n\nNote that any triangle whose sides are all an integer multiple of   '''3, 4, 5''';   such as   '''6, 8, 10,'''   will also be a Heronian triangle.\n\nDefine a '''Primitive Heronian triangle''' as a Heronian triangle where the greatest common divisor \nof all three sides is   '''1'''   (unity). \n\nThis will exclude, for example, triangle   '''6, 8, 10.'''\n\n\n;Task:\n# Create a named function/method/procedure/... that implements Hero's formula.\n# Use the function to generate all the ''primitive'' Heronian triangles with sides <= 200.\n# Show the count of how many triangles are found.\n# Order the triangles by first increasing area, then by increasing perimeter, then by increasing maximum side lengths\n# Show the first ten ordered triangles in a table of sides, perimeter, and area.\n# Show a similar ordered table for those triangles with area = 210\n\n\nShow all output here.\n\n'''Note''': when generating triangles it may help to restrict a <= b <= c\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace heron\n{\n    class Program{\n        static void Main(string[] args){           \n            List<int[]> list = new List<int[]>();\n            for (int c = 1; c <= 200; c++)\n                for (int b = 1; b <= c; b++)\n                    for (int a = 1; a <= b; a++)\n                        if (gcd(a, gcd(b, c)) == 1 && isHeron(heronArea(a, b, c)))\n                            list.Add(new int[] { a, b, c, a + b + c, (int)heronArea(a, b, c)});\n            sort(list);\n            Console.WriteLine(\"Number of primitive Heronian triangles with sides up to 200: \" + list.Count + \"\\n\\nFirst ten when ordered by increasing area, then perimeter,then maximum sides:\\nSides\\t\\t\\tPerimeter\\tArea\");\n            for(int i = 0; i < 10; i++)\n                Console.WriteLine(list[i][0] + \"\\t\" + list[i][1] + \"\\t\" + list[i][2] + \"\\t\" + list[i][3] + \"\\t\\t\" + list[i][4]);\n            Console.WriteLine(\"\\nPerimeter = 210\\nSides\\t\\t\\tPerimeter\\tArea\");\n            foreach (int[] i in list)\n                if (i[4] == 210)\n                    Console.WriteLine(i[0] + \"\\t\" + i[1] + \"\\t\" + i[2] + \"\\t\" + i[3] + \"\\t\\t\" + i[4]);     \n        }\n        static bool isHeron(double heronArea){\n            return heronArea % 1 == 0 && heronArea != 0;\n        }\n        static double heronArea(int a, int b, int c){\n            double s = (a + b + c) / 2d;\n            return Math.Sqrt(s * (s - a) * (s - b) * (s - c));\n        }\n        static int gcd(int a, int b){\n            int remainder = 1, dividend, divisor;\n            dividend = a > b ? a : b;\n            divisor = a > b ? b : a;\n            while (remainder != 0){\n                remainder = dividend % divisor;\n                if (remainder != 0){\n                    dividend = divisor;\n                    divisor = remainder;\n                }\n            }\n            return divisor;\n        }\n        static void sort(List<int[]> list){\n            int[] temp = new int[5];\n            bool changed = true;\n            while(changed){\n                changed = false;\n                for (int i = 1; i < list.Count; i++)\n                    if (list[i][4] < list[i - 1][4] || list[i][4] == list[i - 1][4] && list[i][3] < list[i - 1][3]){\n                        temp = list[i];\n                        list[i] = list[i - 1];\n                        list[i - 1] = temp;\n                        changed = true;\n                    }                \n            }\n        }\n    }\n}"}
{"title": "History variables", "language": "C sharp", "task": "''Storing the history of objects in a program is a common task. \nMaintaining the history of an object in a program has traditionally required programmers either to write specific code for handling the historical data, or to use a library which supports history logging.''\n\n''History variables are variables in a programming language which store not only their current value, but also the values they have contained in the past. Some existing languages do provide support for history variables. However these languages typically have many limits and restrictions on use of history variables.\n'' \n\n\"History Variables: \nThe Semantics, Formal Correctness, and Implementation of History Variables \nin an Imperative Programming Language\" by Mallon and Takaoka\n\nConcept also discussed on LtU and Patents.com.\n\n;Task: \nDemonstrate History variable support: \n* enable history variable support (if needed) \n* define a history variable\n* assign three values\n* non-destructively display the history\n* recall the three values. \n\nFor extra points, if the language of choice does not support history variables, \ndemonstrate how this might be implemented.\n\n", "solution": "using System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace History\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            var h = new HistoryObject();\n            h.Value = 5;\n            h.Value = \"foo\";\n            h.Value += \"bar\";\n\n            var history = h.ToArray();\n\n            for (int i = 0; i < history.Length; i++)\n            {\n                Console.Write(\"{0}{1}\", history[i], ((i >= history.Length - 1) ? \"\\n\" : \" <- \"));\n            }\n\n            h.Undo();\n            h.Undo();\n            h.Undo();\n\n            Console.WriteLine(h.Value);\n        }\n\n        private class HistoryObject : IEnumerable<object>\n        {\n            public HistoryObject()\n            {\n                _history = new Stack<object>(); // Initiates the history stack.\n            }\n\n            public object Value\n            {\n                get // Returns the top value from the history if there is one. Otherwise null.\n                {\n                    if (_history.Count > 0)\n                        return _history.Peek();\n                    return null;\n                }\n                set { _history.Push(value); } // Adds the specified value to the history.\n            }\n\n            public void Undo()\n            {\n                if (_history.Count > 0)\n                    _history.Pop(); // Removes the current value from the history.\n            }\n\n            // History stack that will hold all previous values of the object.\n            private readonly Stack<object> _history;\n\n            public IEnumerator<object> GetEnumerator()\n            {\n                return _history.GetEnumerator();\n            }\n\n            IEnumerator IEnumerable.GetEnumerator()\n            {\n                return GetEnumerator();\n            }\n        }\n    }\n}"}
{"title": "Hofstadter-Conway $10,000 sequence", "language": "C# 3.0", "task": "The definition of the sequence is colloquially described as:\n*   Starting with the list [1,1],\n*   Take the last number in the list so far: 1, I'll call it x.\n*   Count forward x places from the beginning of the list to find the first number to add (1)\n*   Count backward x places from the end of the list to find the second number to add (1)\n*   Add the two indexed numbers from the list and the result becomes the next number in the list (1+1)\n*   This would then produce [1,1,2] where 2 is the third element of the sequence.\n\nNote that indexing for the description above starts from alternately the left and right ends of the list and starts from an index of ''one''.\n\nA less wordy description of the sequence is:\n    a(1)=a(2)=1\n    a(n)=a(a(n-1))+a(n-a(n-1))\n\nThe sequence begins:\n    1, 1, 2, 2, 3, 4, 4, 4, 5, ...\n\nInteresting features of the sequence are that:\n*   a(n)/n   tends to   0.5   as   n   grows towards infinity.\n*   a(n)/n   where   n   is a power of   2   is   0.5\n*   For   n>4   the maximal value of   a(n)/n   between successive powers of 2 decreases.\n\na(n) / n   for   n   in   1..256 \n\n\nThe sequence is so named because John Conway offered a prize of $10,000 to the first person who could\nfind the first position,   p   in the sequence where \n    |a(n)/n| < 0.55  for all  n > p\nIt was later found that Hofstadter had also done prior work on the sequence.\n\nThe 'prize' was won quite quickly by Dr. Colin L. Mallows who proved the properties of the sequence and allowed him to find the value of   n   (which is much smaller than the 3,173,375,556 quoted in the NYT article).\n\n\n;Task:\n#   Create a routine to generate members of the Hofstadter-Conway $10,000 sequence.\n#   Use it to show the maxima of   a(n)/n   between successive powers of two up to   2**20\n#   As a stretch goal:   compute the value of   n   that would have won the prize and confirm it is true for   n   up to 2**20\n\n\n\n;Also see:\n*   Conways Challenge Sequence, Mallows' own account.\n*   Mathworld Article.\n\n", "solution": "using System;\nusing System.Linq;\n\nnamespace HofstadterConway\n{\n    class Program\n    {\n        static int[] GenHofstadterConway(int max)\n        {\n            int[] result = new int[max];\n            result[0]=result[1]=1;\n            for (int ix = 2; ix < max; ix++)\n                result[ix] = result[result[ix - 1] - 1] + result[ix - result[ix - 1]];\n            return result;\n        }\n\n        static void Main(string[] args)\n        {\n            double[] adiv = new double[1 << 20];\n            {\n                int[] a = GenHofstadterConway(1 << 20);\n                for (int i = 0; i < 1 << 20; i++)\n                    adiv[i] = a[i] / (double)(i + 1);\n            }\n            for (int p = 2; p <= 20; p++)\n            {\n                var max = Enumerable.Range(\n                     (1 << (p - 1)) - 1,\n                     (1 << p) - (1 << (p - 1))\n                     )\n                     .Select(ix => new { I = ix + 1, A = adiv[ix] })\n                     .OrderByDescending(x => x.A)\n                     .First();\n                Console.WriteLine(\"Maximum from 2^{0} to 2^{1} is {2} at {3}\",\n                    p - 1, p, max.A, max.I);\n            }\n            Console.WriteLine(\"The winning number is {0}.\",\n                Enumerable.Range(0, 1 << 20)\n                    .Last(i => (adiv[i] > 0.55)) + 1\n                );\n        }\n    }\n}\n"}
{"title": "Hofstadter Figure-Figure sequences", "language": "C sharp|C#", "task": "These two sequences of positive integers are defined as:\n:::: \\begin{align}\nR(1)&=1\\ ;\\ S(1)=2 \\\\\nR(n)&=R(n-1)+S(n-1), \\quad n>1.\n\\end{align}\n\nThe sequence S(n) is further defined as the sequence of positive integers '''''not''''' present in R(n).\n\nSequence R starts: \n    1, 3, 7, 12, 18, ...\nSequence S starts: \n    2, 4, 5, 6, 8, ...\n\n\n;Task:\n# Create two functions named '''ffr''' and '''ffs''' that when given '''n''' return '''R(n)''' or '''S(n)''' respectively.(Note that R(1) = 1 and S(1) = 2 to avoid off-by-one errors).\n# No maximum value for '''n''' should be assumed.\n# Calculate and show that the first ten values of '''R''' are: 1, 3, 7, 12, 18, 26, 35, 45, 56, and 69\n# Calculate and show that the first 40 values of '''ffr''' plus the first 960 values of '''ffs''' include all the integers from 1 to 1000 exactly once.\n\n\n;References:\n* Sloane's A005228 and A030124.\n* Wolfram MathWorld\n* Wikipedia: Hofstadter Figure-Figure sequences.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace HofstadterFigureFigure\n{\n\tclass HofstadterFigureFigure\n\t{\n\t\treadonly List<int> _r = new List<int>() {1};\n\t\treadonly List<int> _s = new List<int>();\n\n\t\tpublic IEnumerable<int> R()\n\t\t{\n\t\t\tint iR = 0;\n\t\t\twhile (true)\n\t\t\t{\n\t\t\t\tif (iR >= _r.Count)\n\t\t\t\t{\n\t\t\t\t\tAdvance();\n\t\t\t\t}\n\t\t\t\tyield return _r[iR++];\n\t\t\t}\n\t\t}\n\n\t\tpublic IEnumerable<int> S()\n\t\t{\n\t\t\tint iS = 0;\n\t\t\twhile (true)\n\t\t\t{\n\t\t\t\tif (iS >= _s.Count)\n\t\t\t\t{\n\t\t\t\t\tAdvance();\n\t\t\t\t}\n\t\t\t\tyield return _s[iS++];\n\t\t\t}\n\t\t}\n\n\t\tprivate void Advance()\n\t\t{\n\t\t\tint rCount = _r.Count;\n\t\t\tint oldR = _r[rCount - 1];\n\t\t\tint sVal;\n\t\t\t\n\t\t\t// Take care of first two cases specially since S won't be larger than R at that point\n\t\t\tswitch (rCount)\n\t\t\t{\n\t\t\t\tcase 1:\n\t\t\t\t\tsVal = 2;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 2:\n\t\t\t\t\tsVal = 4;\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tsVal = _s[rCount - 1];\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\t_r.Add(_r[rCount - 1] + sVal);\n\t\t\tint newR = _r[rCount];\n\t\t\tfor (int iS = oldR + 1; iS < newR; iS++)\n\t\t\t{\n\t\t\t\t_s.Add(iS);\n\t\t\t}\n\t\t}\n\t}\n\n\tclass Program\n\t{\n\t\tstatic void Main()\n\t\t{\n\t\t\tvar hff = new HofstadterFigureFigure();\n\t\t\tvar rs = hff.R();\n\t\t\tvar arr = rs.Take(40).ToList();\n\n\t\t\tforeach(var v in arr.Take(10))\n\t\t\t{\n\t\t\t\tConsole.WriteLine(\"{0}\", v);\n\t\t\t}\n\n\t\t\tvar hs = new HashSet<int>(arr);\n\t\t\ths.UnionWith(hff.S().Take(960));\n\t\t\tConsole.WriteLine(hs.Count == 1000 ? \"Verified\" : \"Oops!  Something's wrong!\");\n\t\t}\n\t}\n}\n"}
{"title": "Hofstadter Q sequence", "language": "C sharp", "task": "The Hofstadter Q sequence is defined as:\n:: \\begin{align}\nQ(1)&=Q(2)=1, \\\\\nQ(n)&=Q\\big(n-Q(n-1)\\big)+Q\\big(n-Q(n-2)\\big), \\quad n>2.\n\\end{align}\n\n\nIt is defined like the [[Fibonacci sequence]], but whereas the next term in the Fibonacci sequence is the sum of the previous two terms, in the Q sequence the previous two terms tell you how far to go back in the Q sequence to find the two numbers to sum to make the next term of the sequence.\n\n\n;Task:\n* Confirm and display that the first ten terms of the sequence are: 1, 1, 2, 3, 3, 4, 5, 5, 6, and 6 \n* Confirm and display that the 1000th term is:   502\n\n\n;Optional extra credit\n* Count and display how many times a member of the sequence is less than its preceding term for terms up to and including the 100,000th term.\n* Ensure that the extra credit solution   ''safely''   handles being initially asked for an '''n'''th term where   '''n'''   is large.\n(This point is to ensure that caching and/or recursion limits, if it is a concern, is correctly handled).\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace HofstadterQSequence\n{\n    class Program\n    {\n        // Initialize the dictionary with the first two indices filled.\n        private static readonly Dictionary<int, int> QList = new Dictionary<int, int>\n                                                                 {\n                                                                     {1, 1},\n                                                                     {2, 1}\n                                                                 };\n\n        private static void Main()\n        {\n            int lessThanLast = 0;\n                /* Initialize our variable that holds the number of times\n                                   * a member of the sequence was less than its preceding term. */\n\n            for (int n = 1; n <= 100000; n++)\n            {\n                int q = Q(n); // Get Q(n).\n\n                if (n > 1 && QList[n - 1] > q) // If Q(n) is less than Q(n - 1),\n                    lessThanLast++;            // then add to the counter.\n\n                if (n > 10 && n != 1000) continue; /* If n is greater than 10 and not 1000,\n                                                    * the rest of the code in the loop does not apply,\n                                                    * and it will be skipped. */\n\n                if (!Confirm(n, q)) // Confirm Q(n) is correct.\n                    throw new Exception(string.Format(\"Invalid result: Q({0}) != {1}\", n, q));\n\n                Console.WriteLine(\"Q({0}) = {1}\", n, q); // Write Q(n) to the console.\n            }\n\n            Console.WriteLine(\"Number of times a member of the sequence was less than its preceding term: {0}.\",\n                              lessThanLast);\n        }\n\n        private static bool Confirm(int n, int value)\n        {\n            if (n <= 10)\n                return new[] {1, 1, 2, 3, 3, 4, 5, 5, 6, 6}[n - 1] == value;\n            if (n == 1000)\n                return 502 == value;\n            throw new ArgumentException(\"Invalid index.\", \"n\");\n        }\n\n        private static int Q(int n)\n        {\n            int q;\n\n            if (!QList.TryGetValue(n, out q)) // Try to get Q(n) from the dictionary.\n            {\n                q = Q(n - Q(n - 1)) + Q(n - Q(n - 2)); // If it's not available, then calculate it.\n                QList.Add(n, q); // Add it to the dictionary.\n            }\n\n            return q;\n        }\n    }\n}"}
{"title": "Honeycombs", "language": "C sharp", "task": "The task is to produce a matrix of 20 hexagon shaped widgets in a honeycomb arrangement. The matrix should be arranged in such a manner that there are five\ncolumns of four hexagons. The hexagons in columns one, three and five are aligned horizontally, whereas the hexagons in columns two and four occupy a lower position within the arrangement. Each hexagon should be the same colour, and should\ndisplay a unique randomly selected single capital letter on the front. The application should now wait for the user to select a hexagon, either by using a pointing device, or by pressing a key that carries a corresponding letter on a hexagon. For platforms that support pointing devices and keyboards, the application should support both methods of selection. A record of the chosen letters should be maintained and the code should be suitably commented, at the point where the the selected letter has been determined. The selected hexagon should now change colour on the display. The cycle repeats until the user has chosen all of the letters. Note that each letter can only be selected once and previously selected hexagons retain their colour after selection. The program terminates when all letters have been chosen.\n\nOptionally: output the list of selected letters and show the last selected letter, cater for a different number of columns or a different number of hexagons in each column, cater for two players, (turns alternate and the hexagons change a different colour depending on whether they were selected by player one or player two and records of both players selections are maintained.)\n\n[[image:honeycomb.gif]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Windows;\nusing System.Windows.Controls;\nusing System.Windows.Input;\nusing System.Windows.Media;\nusing System.Windows.Shapes;\n\n////////////////////////////////////////////////////////////////////////////////////////////////////\n// namespace: Honeycombs\n//\n// summary:\tWPF implementation of Rosetta Code Honeycombs task.  Uses Polygon shapes as hexes.\n////////////////////////////////////////////////////////////////////////////////////////////////////\n\nnamespace Honeycombs\n{\n    public partial class MainWindow\n    {\n        private const int RowCount = 4;\n        private const int ColCount = 5;\n        private const int LabelSize = 20;\n        private readonly char[] _permutedChars;\n\n        public MainWindow()\n        {\n            if (RowCount * ColCount > 26)\n#pragma warning disable 162\n            {\n                throw new ArgumentException(\"Too many cells\");\n            }\n#pragma warning restore 162\n            _permutedChars = GetPermutedChars(RowCount * ColCount);\n\n            // VS Generated code not included\n            InitializeComponent();\n        }\n\n        private static char[] GetPermutedChars(int characterCount)\n        {\n            const string allChars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n            var rnd = new Random();\n            var chars = new char[allChars.Length];\n\n            for (int i = 0; i < allChars.Length; i++)\n            {\n                chars[i] = allChars[i];\n            }\n\n            for (int i = 0; i < characterCount; i++)\n            {\n                int swapIndex = rnd.Next() % (allChars.Length - i);\n                char tmp = chars[swapIndex + i];\n                chars[swapIndex + i] = chars[i];\n                chars[i] = tmp;\n            }\n            return chars;\n        }\n\n        private void SetHexProperties(UIElementCollection hexes, double cellSize)\n        {\n            int charIndex = 0;\n            List<Polygon> hexList = hexes.Cast<Polygon>().ToList();\n\n            foreach (Polygon element in hexList)\n            {\n                SetHexProperties(element, _permutedChars[charIndex++], cellSize);\n            }\n        }\n\n        private void SetHexProperties(Polygon hex, char charToSet, double cellSize)\n        {\n            var tag = (Tuple<int, int, double, double>) hex.Tag;\n            double cellX = tag.Item3;\n            double cellY = tag.Item4;\n\n            // We place the text in a grid centered on the hex.\n            // The grid will then center the text within itself.\n\n            var centeringGrid = new Grid();\n            centeringGrid.Width = centeringGrid.Height = 2 * cellSize;\n            centeringGrid.SetValue(Canvas.LeftProperty, cellX - cellSize);\n            centeringGrid.SetValue(Canvas.TopProperty, cellY - cellSize);\n            centeringGrid.IsHitTestVisible = false;\n            HoneycombCanvas.Children.Add(centeringGrid);\n\n            var label = new TextBlock\n                {\n                    Text = new string(charToSet, 1),\n                    FontFamily = new FontFamily(\"Segoe\"),\n                    FontSize = LabelSize\n                };\n            label.HorizontalAlignment = HorizontalAlignment.Center;\n            label.VerticalAlignment = VerticalAlignment.Center;\n            label.IsHitTestVisible = false;\n            centeringGrid.Children.Add(label);\n\n            // Reset the tag to keep track of the character in the hex\n            hex.Tag = charToSet;\n            hex.Fill = new SolidColorBrush(Colors.Yellow);\n            hex.Stroke = new SolidColorBrush(Colors.Black);\n            hex.StrokeThickness = cellSize / 10;\n\n            // Mouse down event handler for the hex\n            hex.MouseDown += hex_MouseDown;\n        }\n\n        private void hex_MouseDown(object sender, MouseButtonEventArgs e)\n        {\n            var hex = sender as Shape;\n            if (hex == null)\n            {\n                throw new InvalidCastException(\"Non-shape in Honeycomb\");\n            }\n\n            // Get the letter for this hex\n            var ch = (char) hex.Tag;\n\n            // Add it to our Letters TextBlock\n            Letters.Text = Letters.Text + ch;\n\n            // Color the hex magenta\n            hex.Fill = new SolidColorBrush(Colors.Magenta);\n\n            // Remove the mouse down event handler so we won't hit on this hex again\n            hex.MouseDown -= hex_MouseDown;\n        }\n\n        private static void GetCombSize(double actualHeight, double actualWidth, int columns, int rows,\n                                        out double cellSize, out double combHeight, out double combWidth)\n        {\n            double columnFactor = (3 * columns + 1) / 2.0;\n            double rowFactor = (Math.Sqrt(3) * (2 * rows + 1)) / 2.0;\n            double cellFromWidth = actualWidth / columnFactor;\n            double cellFromHeight = actualHeight / rowFactor;\n            cellSize = Math.Min(cellFromWidth, cellFromHeight);\n            combWidth = cellSize * columnFactor;\n            combHeight = cellSize * rowFactor;\n        }\n\n        private static void AddCells(Canvas canvas, double cellSize, int columns, int rows)\n        {\n            double rowHeight = cellSize * Math.Sqrt(3) / 2;\n\n            for (int row = 0; row < rows; row++)\n            {\n                AddRow(rowHeight, canvas, cellSize, columns, row);\n                rowHeight += cellSize * Math.Sqrt(3);\n            }\n        }\n\n        private static void AddRow(double rowHeight, Canvas canvas, double cellSize, int columnCount, int row)\n        {\n            double cellX = cellSize;\n            double cellHeight = cellSize * Math.Sqrt(3);\n\n            for (int col = 0; col < columnCount; col++)\n            {\n                double cellY = rowHeight + ((col & 1) == 1 ? cellHeight / 2 : 0);\n                Polygon hex = GetCenteredHex(cellSize, cellX, cellY, cellHeight);\n                hex.Tag = Tuple.Create(col, row, cellX, cellY);\n                canvas.Children.Add(hex);\n                cellX += 3 * cellSize / 2;\n            }\n        }\n\n        private static Polygon GetCenteredHex(double cellSize, double cellX, double cellY, double cellHeight)\n        {\n            var hex = new Polygon();\n            hex.Points.Add(new Point(cellX - cellSize, cellY));\n            hex.Points.Add(new Point(cellX - cellSize / 2, cellY + cellHeight / 2));\n            hex.Points.Add(new Point(cellX + cellSize / 2, cellY + cellHeight / 2));\n            hex.Points.Add(new Point(cellX + cellSize, cellY));\n            hex.Points.Add(new Point(cellX + cellSize / 2, cellY - cellHeight / 2));\n            hex.Points.Add(new Point(cellX - cellSize / 2, cellY - cellHeight / 2));\n            return hex;\n        }\n\n        private void Window_Loaded(object sender, RoutedEventArgs e)\n        {\n            double combHeight, combWidth, cellSize;\n\n            // Get sizes that will fit within our window\n            GetCombSize(Main.ActualHeight, Main.ActualWidth, ColCount, RowCount, out cellSize, out combHeight,\n                        out combWidth);\n\n            // Set the canvas size appropriately\n            HoneycombCanvas.Width = combWidth;\n            HoneycombCanvas.Height = combHeight;\n\n            // Add the cells to the canvas\n            AddCells(HoneycombCanvas, cellSize, ColCount, RowCount);\n\n            // Set the cells to look like we want them\n            SetHexProperties(HoneycombCanvas.Children, cellSize);\n        }\n    }\n}"}
{"title": "Horner's rule for polynomial evaluation", "language": "C sharp|C#", "task": "A fast scheme for evaluating a polynomial such as:\n: -19+7x-4x^2+6x^3\\,\nwhen\n: x=3\\;.\nis to arrange the computation as follows:\n: ((((0) x + 6) x + (-4)) x + 7) x + (-19)\\;\nAnd compute the result from the innermost brackets outwards as in this pseudocode:\n coefficients ''':=''' [-19, 7, -4, 6] ''# list coefficients of all x^0..x^n in order''\n x ''':=''' 3\n accumulator ''':=''' 0\n '''for''' i '''in''' ''length''(coefficients) '''downto''' 1 '''do'''\n     ''# Assumes 1-based indexing for arrays''\n     accumulator ''':=''' ( accumulator * x ) + coefficients[i]\n '''done'''\n ''# accumulator now has the answer''\n\n'''Task Description'''\n:Create a routine that takes a list of coefficients of a polynomial in order of increasing powers of x; together with a value of x to compute its value at, and return the value of the polynomial at that value using Horner's rule.\n\nCf. [[Formal power series]]\n\n", "solution": "using System;\nusing System.Linq;\n\nclass Program\n{\n    static double Horner(double[] coefficients, double variable)\n    {\n        return coefficients.Reverse().Aggregate(\n                (accumulator, coefficient) => accumulator * variable + coefficient);\n    }\n\n    static void Main()\n    {\n        Console.WriteLine(Horner(new[] { -19.0, 7.0, -4.0, 6.0 }, 3.0));\n    }\n}"}
{"title": "ISBN13 check digit", "language": "C sharp", "task": "Validate the check digit of an ISBN-13 code:\n::*   Multiply every other digit by  '''3'''.\n::*   Add these numbers and the other digits.\n::*   Take the remainder of this number after division by  '''10'''.\n::*   If it is  '''0''',   the ISBN-13 check digit is correct.\n\n\nYou might use the following codes for testing:\n::::*   978-0596528126              (good)\n::::*   978-0596528120          (bad)\n::::*   978-1788399081              (good)\n::::*   978-1788399083          (bad)\n\n\nShow output here, on this page\n\n\n;See also:\n:*   for details:   13-digit ISBN method of validation.       (installs cookies.)\n\n", "solution": "using System;\nusing System.Linq;\n\npublic class Program\n{\n    public static void Main() {\n        Console.WriteLine(CheckISBN13(\"978-1734314502\"));\n        Console.WriteLine(CheckISBN13(\"978-1734314509\"));\n        Console.WriteLine(CheckISBN13(\"978-1788399081\"));\n        Console.WriteLine(CheckISBN13(\"978-1788399083\"));\n\n        static bool CheckISBN13(string code) {\n            code = code.Replace(\"-\", \"\").Replace(\" \", \"\");\n            if (code.Length != 13) return false;\n            int sum = 0;\n            foreach (var (index, digit) in code.Select((digit, index) => (index, digit))) {\n                if (char.IsDigit(digit)) sum += (digit - '0') * (index % 2 == 0 ? 1 : 3);\n                else return false;\n            }\n            return sum % 10 == 0;\n        }\n    }\n}"}
{"title": "I before E except after C", "language": "C sharp|C# from Java", "task": "The phrase      \"I before E, except after C\"     is a \nwidely known mnemonic which is supposed to help when spelling English words.\n\n\n;Task:\nUsing the word list from   http://wiki.puzzlers.org/pub/wordlists/unixdict.txt, \ncheck if the two sub-clauses of the phrase are plausible individually:\n:::#   ''\"I before E when not preceded by C\"''\n:::#   ''\"E before I when preceded by C\"''\n\n\nIf both sub-phrases are plausible then the original phrase can be said to be plausible.\n\nSomething is plausible if the number of words having the feature is more than two times the number of words having the opposite feature (where feature is 'ie' or 'ei' preceded or not by 'c' as appropriate).\n \n\n;Stretch goal:\nAs a stretch goal use the entries from the table of Word Frequencies in Written and Spoken English: based on the British National Corpus, (selecting those rows with three space or tab separated words only), to see if the phrase is plausible when word frequencies are taken into account.\n\n\n''Show your output here as well as your program.''\n\n\n\n\n;cf.:\n* Schools to rethink 'i before e' - BBC news, 20 June 2009\n* I Before E Except After C - QI Series 8 Ep 14, (humorous)\n* Companion website for the book: \"Word Frequencies in Written and Spoken English: based on the British National Corpus\".\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.IO;\n\nnamespace IBeforeE {\n    class Program {\n        static bool IsOppPlausibleWord(string word) {\n            if (!word.Contains(\"c\") && word.Contains(\"ei\")) {\n                return true;\n            }\n            if (word.Contains(\"cie\")) {\n                return true;\n            }\n            return false;\n        }\n\n        static bool IsPlausibleWord(string word) {\n            if (!word.Contains(\"c\") && word.Contains(\"ie\")) {\n                return true;\n            }\n            if (word.Contains(\"cei\")) {\n                return true;\n            }\n            return false;\n        }\n\n        static bool IsPlausibleRule(string filename) {\n            IEnumerable<string> wordSource = File.ReadLines(filename);\n            int trueCount = 0;\n            int falseCount = 0;\n\n            foreach (string word in wordSource) {\n                if (IsPlausibleWord(word)) {\n                    trueCount++;\n                }\n                else if (IsOppPlausibleWord(word)) {\n                    falseCount++;\n                }\n            }\n\n            Console.WriteLine(\"Plausible count: {0}\", trueCount);\n            Console.WriteLine(\"Implausible count: {0}\", falseCount);\n            return trueCount > 2 * falseCount;\n        }\n\n        static void Main(string[] args) {\n            if (IsPlausibleRule(\"unixdict.txt\")) {\n                Console.WriteLine(\"Rule is plausible.\");\n            }\n            else {\n                Console.WriteLine(\"Rule is not plausible.\");\n            }\n        }\n    }\n}"}
{"title": "I before E except after C", "language": ".NET Core 2.1", "task": "The phrase      \"I before E, except after C\"     is a \nwidely known mnemonic which is supposed to help when spelling English words.\n\n\n;Task:\nUsing the word list from   http://wiki.puzzlers.org/pub/wordlists/unixdict.txt, \ncheck if the two sub-clauses of the phrase are plausible individually:\n:::#   ''\"I before E when not preceded by C\"''\n:::#   ''\"E before I when preceded by C\"''\n\n\nIf both sub-phrases are plausible then the original phrase can be said to be plausible.\n\nSomething is plausible if the number of words having the feature is more than two times the number of words having the opposite feature (where feature is 'ie' or 'ei' preceded or not by 'c' as appropriate).\n \n\n;Stretch goal:\nAs a stretch goal use the entries from the table of Word Frequencies in Written and Spoken English: based on the British National Corpus, (selecting those rows with three space or tab separated words only), to see if the phrase is plausible when word frequencies are taken into account.\n\n\n''Show your output here as well as your program.''\n\n\n\n\n;cf.:\n* Schools to rethink 'i before e' - BBC news, 20 June 2009\n* I Before E Except After C - QI Series 8 Ep 14, (humorous)\n* Companion website for the book: \"Word Frequencies in Written and Spoken English: based on the British National Corpus\".\n\n", "solution": "Option Compare Binary\nOption Explicit On\nOption Infer On\nOption Strict On\n\nImports System.Text.RegularExpressions\n\n#Const USE_REGEX = False\n\nModule Program\n    ' Supports both local and remote files\n    Const WORDLIST_URI = \"http://wiki.puzzlers.org/pub/wordlists/unixdict.txt\"\n\n\n    ' The support factor of a word for EI or IE is the number of occurrences that support the rule minus the number that oppose it.\n    ' I.e., for IE:\n    '   - increased when not preceded by C\n    '   - decreased when preceded by C\n    ' and for EI:\n    '   - increased when preceded by C\n    '   - decreased when not preceded by C\n    Private Function GetSupportFactor(word As String) As (IE As Integer, EI As Integer)\n        Dim IE, EI As Integer\n\n        ' Enumerate the letter pairs in the word.\n        For i = 0 To word.Length - 2\n            Dim pair = word.Substring(i, 2)\n\n            ' Instances at the beginning of a word count towards the factor and are treated as not preceded by C.\n            Dim prevIsC As Boolean = i > 0 AndAlso String.Equals(word(i - 1), \"c\"c, StringComparison.OrdinalIgnoreCase)\n\n            If pair.Equals(\"ie\", StringComparison.OrdinalIgnoreCase) Then\n                IE += If(Not prevIsC, 1, -1)\n            ElseIf pair.Equals(\"ei\", StringComparison.OrdinalIgnoreCase) Then\n                EI += If(prevIsC, 1, -1)\n            End If\n        Next\n\n        If Math.Abs(IE) > 1 Or Math.Abs(EI) > 1 Then Debug.WriteLine($\"{word}: {GetSupportFactor}\")\n        Return (IE, EI)\n    End Function\n\n\n    ' Returns the number of words that support or oppose the rule.\n    Private Function GetPlausabilities(words As IEnumerable(Of String)) As (ieSuppCount As Integer, ieOppCount As Integer, eiSuppCount As Integer, eiOppCount As Integer)\n        Dim ieSuppCount, ieOppCount, eiSuppCount, eiOppCount As Integer\n\n        For Each word In words\n            Dim status = GetSupportFactor(word)\n            If status.IE > 0 Then\n                ieSuppCount += 1\n            ElseIf status.IE < 0 Then\n                ieOppCount += 1\n            End If\n            If status.EI > 0 Then\n                eiSuppCount += 1\n            ElseIf status.EI < 0 Then\n                eiOppCount += 1\n            End If\n        Next\n\n        Return (ieSuppCount, ieOppCount, eiSuppCount, eiOppCount)\n    End Function\n\n\n    ' Takes entire file instead of individual words.\n    ' Returns the number of instances of IE or EI that support or oppose the rule.\n    Private Function GetPlausabilitiesRegex(words As String) As (ieSuppCount As Integer, ieOppCount As Integer, eiSuppCount As Integer, eiOppCount As Integer)\n        ' Gets number of occurrences of the pattern, case-insensitive.\n        Dim count = Function(pattern As String) Regex.Matches(words, pattern, RegexOptions.IgnoreCase).Count\n\n        Dim ie = count(\"[^c]ie\")\n        Dim ei = count(\"[^c]ei\")\n        Dim cie = count(\"cie\")\n        Dim cei = count(\"cei\")\n\n        Return (ie, cie, cei, ei)\n    End Function\n\n\n    Sub Main()\n        Dim file As String\n        Dim wc As New Net.WebClient()\n        Try\n            Console.WriteLine(\"Fetching file...\")\n            file = wc.DownloadString(WORDLIST_URI)\n            Console.WriteLine(\"Success.\")\n            Console.WriteLine()\n        Catch ex As Net.WebException\n            Console.WriteLine(ex.Message)\n            Exit Sub\n        Finally\n            wc.Dispose()\n        End Try\n\n#If USE_REGEX Then\n        Dim res = GetPlausabilitiesRegex(file)\n#Else\n        Dim words = file.Split({vbCr, vbLf}, StringSplitOptions.RemoveEmptyEntries)\n        Dim res = GetPlausabilities(words)\n#End If\n\n        Dim PrintResult =\n        Function(suppCount As Integer, oppCount As Integer, printEI As Boolean) As Boolean\n            Dim ratio = suppCount / oppCount,\n                plausible = ratio > 2\n#If Not USE_REGEX Then\n            Console.WriteLine($\"    Words with no instances of {If(printEI, \"EI\", \"IE\")} or equal numbers of supporting/opposing occurrences: {words.Length - suppCount - oppCount}\")\n#End If\n            Console.WriteLine($\"    Number supporting: {suppCount}\")\n            Console.WriteLine($\"    Number opposing: {oppCount}\")\n            Console.WriteLine($\"    {suppCount}/{oppCount}={ratio:N3}\")\n            Console.WriteLine($\"    Rule therefore IS {If(plausible, \"\", \"NOT \")}plausible.\")\n            Return plausible\n        End Function\n\n#If USE_REGEX Then\n        Console.WriteLine($\"Total occurrences of IE: {res.ieOppCount + res.ieSuppCount}\")\n        Console.WriteLine($\"Total occurrences of EI: {res.eiOppCount + res.eiSuppCount}\")\n#Else\n        Console.WriteLine($\"Total words: {words.Length}\")\n#End If\n\n        Console.WriteLine()\n        Console.WriteLine(\"\"\"IE is not preceded by C\"\"\")\n        Dim iePlausible = PrintResult(res.ieSuppCount, res.ieOppCount, False)\n\n        Console.WriteLine()\n        Console.WriteLine(\"\"\"EI is preceded by C\"\"\")\n        Dim eiPlausible = PrintResult(res.eiSuppCount, res.eiOppCount, True)\n\n        Console.WriteLine()\n        Console.WriteLine($\"Rule thus overall IS {If(iePlausible AndAlso eiPlausible, \"\", \"NOT \")}plausible.\")\n    End Sub\nEnd Module\n"}
{"title": "Identity matrix", "language": "C sharp", "task": "Build an   identity matrix   of a size known at run-time. \n\n\nAn ''identity matrix'' is a square matrix of size '''''n'' x ''n''''', \nwhere the diagonal elements are all '''1'''s (ones), \nand all the other elements are all '''0'''s (zeroes).\n\n\nI_n = \\begin{bmatrix}\n  1      & 0      & 0      & \\cdots & 0      \\\\\n  0      & 1      & 0      & \\cdots & 0      \\\\\n  0      & 0      & 1      & \\cdots & 0      \\\\\n  \\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n  0      & 0      & 0      & \\cdots & 1      \\\\\n\\end{bmatrix}\n\n\n;Related tasks:\n*   [[Spiral matrix]]\n*   [[Zig-zag matrix]] \n*   [[Ulam_spiral_(for_primes)]]\n\n", "solution": "using System;\nusing System.Linq;\n\nnamespace IdentityMatrix\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            if (args.Length != 1)\n            {\n                Console.WriteLine(\"Requires exactly one argument\");\n                return;\n            }\n            int n;\n            if (!int.TryParse(args[0], out n))\n            {\n                Console.WriteLine(\"Requires integer parameter\");\n                return;\n            }\n\n            var identity =\n                Enumerable.Range(0, n).Select(i => Enumerable.Repeat(0, n).Select((z,j) => j == i ? 1 : 0).ToList()).ToList();\n            foreach (var row in identity)\n            {\n                foreach (var elem in row)\n                {\n                    Console.Write(\" \" + elem);\n                }\n                Console.WriteLine();\n            }\n            Console.ReadKey();\n        }\n    }\n}\n"}
{"title": "Imaginary base numbers", "language": "C sharp|C#", "task": "Imaginary base numbers are a non-standard positional numeral system which uses an imaginary number as its radix. The most common is quater-imaginary with radix 2i. \n\n''The quater-imaginary numeral system was first proposed by Donald Knuth in 1955 as a submission for a high school science talent search.  [Ref.]''\n\nOther imaginary bases are possible too but are not as widely discussed and aren't specifically named.\n\n'''Task:''' Write a set of procedures (functions, subroutines, however they are referred to in your language) to convert base 10 numbers to an imaginary base and back. \n\nAt a minimum, support quater-imaginary (base 2i).\n\nFor extra kudos, support positive or negative bases 2i through 6i (or higher).\n\nAs a stretch goal, support converting non-integer numbers ( E.G. 227.65625+10.859375i ) to an imaginary base.\n\nSee Wikipedia: Quater-imaginary_base for more details. \n\nFor reference, here are some some decimal and complex numbers converted to quater-imaginary.\n\n\n\n\n\nBase 10\nBase 2i\n\n\n1\n 1\n\n\n2\n 2\n\n\n3\n 3\n\n\n4\n 10300\n\n\n5\n 10301\n\n\n6\n 10302\n\n\n7\n 10303\n\n\n8\n 10200\n\n\n9\n 10201\n\n\n10\n 10202\n\n\n11\n 10203\n\n\n12\n 10100\n\n\n13\n 10101\n\n\n14\n 10102\n\n\n15\n 10103\n\n\n16\n 10000\n\n\n\n\n\n\nBase 10\nBase 2i\n\n\n-1\n 103\n\n\n-2\n 102\n\n\n-3\n 101\n\n\n-4\n 100\n\n\n-5\n 203\n\n\n-6\n 202\n\n\n-7\n 201\n\n\n-8\n 200\n\n\n-9\n 303\n\n\n-10\n 302\n\n\n-11\n 301\n\n\n-12\n 300\n\n\n-13\n 1030003\n\n\n-14\n 1030002\n\n\n-15\n 1030001\n\n\n-16\n 1030000\n\n\n\n\n\n\nBase 10\nBase 2i\n\n\n1i\n10.2\n\n\n2i\n10.0\n\n\n3i\n20.2\n\n\n4i\n20.0\n\n\n5i\n30.2\n\n\n6i\n30.0\n\n\n7i\n103000.2\n\n\n8i\n103000.0\n\n\n9i\n103010.2\n\n\n10i\n103010.0\n\n\n11i\n103020.2\n\n\n12i\n103020.0\n\n\n13i\n103030.2\n\n\n14i\n103030.0\n\n\n15i\n102000.2\n\n\n16i\n102000.0\n\n\n\n\n\n\nBase 10\nBase 2i\n\n\n-1i\n0.2\n\n\n-2i\n1030.0\n\n\n-3i\n1030.2\n\n\n-4i\n1020.0\n\n\n-5i\n1020.2\n\n\n-6i\n1010.0\n\n\n-7i\n1010.2\n\n\n-8i\n1000.0\n\n\n-9i\n1000.2\n\n\n-10i\n2030.0\n\n\n-11i\n2030.2\n\n\n-12i\n2020.0\n\n\n-13i\n2020.2\n\n\n-14i\n2010.0\n\n\n-15i\n2010.2\n\n\n-16i\n2000.0\n\n\n\n\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Text;\n\nnamespace ImaginaryBaseNumbers {\n    class Complex {\n        private double real, imag;\n\n        public Complex(int r, int i) {\n            real = r;\n            imag = i;\n        }\n\n        public Complex(double r, double i) {\n            real = r;\n            imag = i;\n        }\n\n        public static Complex operator -(Complex self) =>\n            new Complex(-self.real, -self.imag);\n\n        public static Complex operator +(Complex rhs, Complex lhs) =>\n            new Complex(rhs.real + lhs.real, rhs.imag + lhs.imag);\n\n        public static Complex operator -(Complex rhs, Complex lhs) =>\n            new Complex(rhs.real - lhs.real, rhs.imag - lhs.imag);\n\n        public static Complex operator *(Complex rhs, Complex lhs) =>\n            new Complex(\n                rhs.real * lhs.real - rhs.imag * lhs.imag,\n                rhs.real * lhs.imag + rhs.imag * lhs.real\n                );\n\n        public static Complex operator *(Complex rhs, double lhs) =>\n             new Complex(rhs.real * lhs, rhs.imag * lhs);\n\n        public static Complex operator /(Complex rhs, Complex lhs) =>\n            rhs * lhs.Inv();\n\n        public Complex Inv() {\n            double denom = real * real + imag * imag;\n            return new Complex(real / denom, -imag / denom);\n        }\n\n        public QuaterImaginary ToQuaterImaginary() {\n            if (real == 0.0 && imag == 0.0) return new QuaterImaginary(\"0\");\n            int re = (int)real;\n            int im = (int)imag;\n            int fi = -1;\n            StringBuilder sb = new StringBuilder();\n            while (re != 0) {\n                int rem = re % -4;\n                re /= -4;\n                if (rem < 0) {\n                    rem = 4 + rem;\n                    re++;\n                }\n                sb.Append(rem);\n                sb.Append(0);\n            }\n            if (im != 0) {\n                double f = (new Complex(0.0, imag) / new Complex(0.0, 2.0)).real;\n                im = (int)Math.Ceiling(f);\n                f = -4.0 * (f - im);\n                int index = 1;\n                while (im != 0) {\n                    int rem = im % -4;\n                    im /= -4;\n                    if (rem < 0) {\n                        rem = 4 + rem;\n                        im++;\n                    }\n                    if (index < sb.Length) {\n                        sb[index] = (char)(rem + 48);\n                    } else {\n                        sb.Append(0);\n                        sb.Append(rem);\n                    }\n                    index += 2;\n                }\n                fi = (int)f;\n            }\n            string reverse = new string(sb.ToString().Reverse().ToArray());\n            sb.Length = 0;\n            sb.Append(reverse);\n            if (fi != -1) sb.AppendFormat(\".{0}\", fi);\n            string s = sb.ToString().TrimStart('0');\n            if (s[0] == '.') s = \"0\" + s;\n            return new QuaterImaginary(s);\n        }\n\n        public override string ToString() {\n            double real2 = (real == -0.0) ? 0.0 : real;  // get rid of negative zero\n            double imag2 = (imag == -0.0) ? 0.0 : imag;  // ditto\n            if (imag2 == 0.0) {\n                return string.Format(\"{0}\", real2);\n            }\n            if (real2 == 0.0) {\n                return string.Format(\"{0}i\", imag2);\n            }\n            if (imag2 > 0.0) {\n                return string.Format(\"{0} + {1}i\", real2, imag2);\n            }\n            return string.Format(\"{0} - {1}i\", real2, -imag2);\n        }\n    }\n\n    class QuaterImaginary {\n        internal static Complex twoI = new Complex(0.0, 2.0);\n        internal static Complex invTwoI = twoI.Inv();\n\n        private string b2i;\n\n        public QuaterImaginary(string b2i) {\n            if (b2i == \"\" || !b2i.All(c => \"0123.\".IndexOf(c) > -1) || b2i.Count(c => c == '.') > 1) {\n                throw new Exception(\"Invalid Base 2i number\");\n            }\n            this.b2i = b2i;\n        }\n\n        public Complex ToComplex() {\n            int pointPos = b2i.IndexOf(\".\");\n            int posLen = (pointPos != -1) ? pointPos : b2i.Length;\n            Complex sum = new Complex(0.0, 0.0);\n            Complex prod = new Complex(1.0, 0.0);\n            for (int j = 0; j < posLen; j++) {\n                double k = (b2i[posLen - 1 - j] - '0');\n                if (k > 0.0) {\n                    sum += prod * k;\n                }\n                prod *= twoI;\n            }\n            if (pointPos != -1) {\n                prod = invTwoI;\n                for (int j = posLen + 1; j < b2i.Length; j++) {\n                    double k = (b2i[j] - '0');\n                    if (k > 0.0) {\n                        sum += prod * k;\n                    }\n                    prod *= invTwoI;\n                }\n            }\n\n            return sum;\n        }\n\n        public override string ToString() {\n            return b2i;\n        }\n    }\n\n    class Program {\n        static void Main(string[] args) {\n            for (int i = 1; i <= 16; i++) {\n                Complex c1 = new Complex(i, 0);\n                QuaterImaginary qi = c1.ToQuaterImaginary();\n                Complex c2 = qi.ToComplex();\n                Console.Write(\"{0,4} -> {1,8} -> {2,4}     \", c1, qi, c2);\n                c1 = -c1;\n                qi = c1.ToQuaterImaginary();\n                c2 = qi.ToComplex();\n                Console.WriteLine(\"{0,4} -> {1,8} -> {2,4}\", c1, qi, c2);\n            }\n            Console.WriteLine();\n            for (int i = 1; i <= 16; i++) {\n                Complex c1 = new Complex(0, i);\n                QuaterImaginary qi = c1.ToQuaterImaginary();\n                Complex c2 = qi.ToComplex();\n                Console.Write(\"{0,4} -> {1,8} -> {2,4}     \", c1, qi, c2);\n                c1 = -c1;\n                qi = c1.ToQuaterImaginary();\n                c2 = qi.ToComplex();\n                Console.WriteLine(\"{0,4} -> {1,8} -> {2,4}\", c1, qi, c2);\n            }\n        }\n    }\n}"}
{"title": "Include a file", "language": "C sharp", "task": "Demonstrate the language's ability to include source code from other files.\n\n\n;See Also\n\n* [[Compiler/Simple file inclusion pre processor]]\n\n\n", "solution": "/* The C# language specification does not give a mechanism for 'including' one source file within another,\n * likely because there is no need - all code compiled within one 'assembly' (individual IDE projects\n * are usually compiled to separate assemblies) can 'see' all other code within that assembly.\n */"}
{"title": "Integer overflow", "language": "C sharp", "task": "Some languages support one or more integer types of the underlying processor.\n\nThis integer types have fixed size;   usually   '''8'''-bit,   '''16'''-bit,   '''32'''-bit,   or   '''64'''-bit.\nThe integers supported by such a type can be   ''signed''   or   ''unsigned''.\n\nArithmetic for machine level integers can often be done by single CPU instructions.\nThis allows high performance and is the main reason to support machine level integers.\n\n\n;Definition:\nAn integer overflow happens when the result of a computation does not fit into the fixed size integer.\nThe result can be too small or too big to be representable in the fixed size integer.\n\n\n;Task:\nWhen a language has fixed size integer types, create a program that\ndoes arithmetic computations for the fixed size integers of the language.\n\nThese computations must be done such that the result would overflow.\n\nThe program should demonstrate what the following expressions do.\n\n\nFor 32-bit signed integers:\n::::: {|class=\"wikitable\"\n!Expression\n!Result that does not fit into a 32-bit signed integer\n|-\n| -(-2147483647-1)\n| 2147483648\n|-\n| 2000000000 + 2000000000\n| 4000000000\n|-\n| -2147483647 - 2147483647\n| -4294967294\n|-\n| 46341 * 46341\n| 2147488281\n|-\n| (-2147483647-1) / -1\n| 2147483648\n|}\n\nFor 64-bit signed integers:\n::: {|class=\"wikitable\"\n!Expression\n!Result that does not fit into a 64-bit signed integer\n|-\n| -(-9223372036854775807-1)\n| 9223372036854775808\n|-\n| 5000000000000000000+5000000000000000000\n| 10000000000000000000\n|-\n| -9223372036854775807 - 9223372036854775807\n| -18446744073709551614\n|-\n| 3037000500 * 3037000500\n| 9223372037000250000\n|-\n| (-9223372036854775807-1) / -1\n| 9223372036854775808\n|}\n\nFor 32-bit unsigned integers:\n::::: {|class=\"wikitable\"\n!Expression\n!Result that does not fit into a 32-bit unsigned integer\n|-\n| -4294967295\n| -4294967295\n|-\n| 3000000000 + 3000000000\n| 6000000000\n|-\n| 2147483647 - 4294967295\n| -2147483648\n|-\n| 65537 * 65537\n| 4295098369\n|}\n\nFor 64-bit unsigned integers:\n::: {|class=\"wikitable\"\n!Expression\n!Result that does not fit into a 64-bit unsigned integer\n|-\n| -18446744073709551615\n| -18446744073709551615\n|-\n| 10000000000000000000 + 10000000000000000000\n| 20000000000000000000\n|-\n| 9223372036854775807 - 18446744073709551615\n| -9223372036854775808\n|-\n| 4294967296 * 4294967296\n| 18446744073709551616\n|}\n\n\n;Notes:\n:*   When the integer overflow does trigger an exception show how the exception is caught.\n:*   When the integer overflow produces some value,   print it.\n:*   It should be explicitly noted when an integer overflow is not recognized,   the program continues with wrong results.\n:*   This should be done for signed and unsigned integers of various sizes supported by the computer programming language.\n:*   When a language has no fixed size integer type,   or when no integer overflow can occur for other reasons,   this should be noted.\n:*   It is okay to mention,   when a language supports unlimited precision integers,   but this task is NOT the place to demonstrate the   capabilities of unlimited precision integers.\n\n", "solution": "using System;\n    \npublic class IntegerOverflow\n{\n    public static void Main() {\n        unchecked {\n            Console.WriteLine(\"For 32-bit signed integers:\");\n            Console.WriteLine(-(-2147483647 - 1));\n            Console.WriteLine(2000000000 + 2000000000);\n            Console.WriteLine(-2147483647 - 2147483647);\n            Console.WriteLine(46341 * 46341);\n            Console.WriteLine((-2147483647 - 1) / -1);\n            Console.WriteLine();\n            \n            Console.WriteLine(\"For 64-bit signed integers:\");\n            Console.WriteLine(-(-9223372036854775807L - 1));\n            Console.WriteLine(5000000000000000000L + 5000000000000000000L);\n            Console.WriteLine(-9223372036854775807L - 9223372036854775807L);\n            Console.WriteLine(3037000500L * 3037000500L);\n            Console.WriteLine((-9223372036854775807L - 1) / -1);\n            Console.WriteLine();\n\n            Console.WriteLine(\"For 32-bit unsigned integers:\");\n            //Negating a 32-bit unsigned integer will convert it to a signed 64-bit integer.\n            Console.WriteLine(-4294967295U);\n            Console.WriteLine(3000000000U + 3000000000U);\n            Console.WriteLine(2147483647U - 4294967295U);\n            Console.WriteLine(65537U * 65537U);\n            Console.WriteLine();\n\n            Console.WriteLine(\"For 64-bit unsigned integers:\");\n            // The - operator cannot be applied to 64-bit unsigned integers; it will always give a compile-time error.\n            //Console.WriteLine(-18446744073709551615UL);\n            Console.WriteLine(10000000000000000000UL + 10000000000000000000UL);\n            Console.WriteLine(9223372036854775807UL - 18446744073709551615UL);\n            Console.WriteLine(4294967296UL * 4294967296UL);\n            Console.WriteLine();\n        }\n        \n        int i = 2147483647;\n        Console.WriteLine(i + 1);\n        try {\n            checked { Console.WriteLine(i + 1); }\n        } catch (OverflowException) {\n            Console.WriteLine(\"Overflow!\");\n        }\n    }\n    \n}"}
{"title": "Integer sequence", "language": "C sharp|C#", "task": "Create a program that, when run, would display all integers from   '''1'''   to    '''    '''    (or any relevant implementation limit),   in sequence   (i.e.   1, 2, 3, 4, etc)   if given enough time.\n\n\nAn example may not be able to reach arbitrarily-large numbers based on implementations limits.   For example, if integers are represented as a 32-bit unsigned value with 0 as the smallest representable value, the largest representable value would be 4,294,967,295.   Some languages support arbitrarily-large numbers as a built-in feature, while others make use of a module or library.\n\nIf appropriate, provide an example which reflect the language implementation's common built-in limits as well as an example which supports arbitrarily large numbers, and describe the nature of such limitations--or lack thereof.\n\n", "solution": "using System;\nusing System.Numerics;\n\nclass Program\n{\n    static void Main()\n    {\n        BigInteger i = 1;\n        while (true)\n        {\n            Console.WriteLine(i++);\n        }\n    }\n}"}
{"title": "Intersecting number wheels", "language": "C sharp", "task": "A number wheel has:\n* A ''name'' which is an uppercase letter.\n* A set of ordered ''values'' which are either ''numbers'' or ''names''.\n\nA ''number'' is generated/yielded from a named wheel by:\n:1. Starting at the first value of the named wheel and advancing through subsequent values and wrapping around to the first value to form a \"wheel\":\n::1.a If the value is a number, yield it.\n::1.b If the value is a name, yield the next value from the named wheel\n::1.c Advance the position of this wheel.\n\nGiven the wheel\n: A: 1 2 3\nthe number 1 is first generated, then 2, then 3, 1, 2, 3, 1, ...\n\n'''Note:''' When more than one wheel is defined as a set of intersecting wheels then the \nfirst named wheel is assumed to be the one that values are generated from.\n\n;Examples:\nGiven the wheels:\n    A: 1 B 2\n    B: 3 4\nThe series of numbers generated starts:\n    1, 3, 2, 1, 4, 2, 1, 3, 2, 1, 4, 2, 1, 3, 2...\n\nThe intersections of number wheels can be more complex, (and might loop forever),\nand wheels may be multiply connected. \n\n'''Note:''' If a named wheel is referenced more than \nonce by one or many other wheels, then there is only one position of the wheel \nthat is advanced by each and all references to it.\n\nE.g.\n  A:  1 D D\n  D:  6 7 8\n  Generates:\n    1 6 7 1 8 6 1 7 8 1 6 7 1 8 6 1 7 8 1 6 ...    \n\n;Task:\nGenerate and show the first twenty terms of the sequence of numbers generated \nfrom these groups:\n\n    Intersecting Number Wheel group:\n      A:  1 2 3\n    \n    Intersecting Number Wheel group:\n      A:  1 B 2\n      B:  3 4\n    \n    Intersecting Number Wheel group:\n      A:  1 D D\n      D:  6 7 8\n    \n    Intersecting Number Wheel group:\n      A:  1 B C\n      B:  3 4\n      C:  5 B\n\nShow your output here, on this page.\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic static class IntersectingNumberWheels\n{\n    public static void Main() {\n        TurnWheels(('A', \"123\")).Take(20).Print();\n        TurnWheels(('A', \"1B2\"), ('B', \"34\")).Take(20).Print();\n        TurnWheels(('A', \"1DD\"), ('D', \"678\")).Take(20).Print();\n        TurnWheels(('A', \"1BC\"), ('B', \"34\"), ('C', \"5B\")).Take(20).Print();\n    }\n\n    static IEnumerable<char> TurnWheels(params (char name, string values)[] wheels) {\n        var data = wheels.ToDictionary(wheel => wheel.name, wheel => wheel.values.Loop().GetEnumerator());\n        var primary = data[wheels[0].name];\n        while (true) {\n            yield return Turn(primary);\n        }\n\n        char Turn(IEnumerator<char> sequence) {\n            sequence.MoveNext();\n            char c = sequence.Current;\n            return char.IsDigit(c) ? c : Turn(data[c]);\n        }\n    }\n\n    static IEnumerable<T> Loop<T>(this IEnumerable<T> seq) {\n        while (true) {\n            foreach (T element in seq) yield return element;\n        }\n    }\n\n    static void Print(this IEnumerable<char> sequence) => Console.WriteLine(string.Join(\" \", sequence));\n}"}
{"title": "Iterated digits squaring", "language": "C sharp", "task": "If you add the square of the digits of a Natural number (an integer bigger than zero), you always end with either 1 or 89:\n15 -> 26 -> 40 -> 16 -> 37 -> 58 -> 89\n7 -> 49 -> 97 -> 130 -> 10 -> 1\n\nAn example in Python:\n\n>>> step = lambda x: sum(int(d) ** 2 for d in str(x))\n>>> iterate = lambda x: x if x in [1, 89] else iterate(step(x))\n>>> [iterate(x) for x in xrange(1, 20)]\n[1, 89, 89, 89, 89, 89, 1, 89, 89, 1, 89, 89, 1, 89, 89, 89, 89, 89, 1]\n\n\n;Task:\n: Count how many number chains for integers 1 <= n < 100_000_000 end with a value 89.\nOr, for much less credit - (showing that your algorithm and/or language is slow):\n: Count how many number chains for integers 1 <= n < 1_000_000 end with a value 89.\n\nThis problem derives from the Project Euler problem 92.\n\nFor a quick algorithm for this task see the talk page\n\n\n;Related tasks:\n* [[Combinations with repetitions]]\n* [[Digital root]]\n* [[Digital root/Multiplicative digital root]]\n\n", "solution": "using System;\npublic static class IteratedDigitsSquaring\n{\n    public static void Main() {\n        Console.WriteLine(Count89s(1_000_000));\n        Console.WriteLine(Count89s(100_000_000));\n    }\n\n    public static int Count89s(int limit) {\n        if (limit < 1) return 0;\n        int[] end = new int[Math.Min(limit, 9 * 9 * 9 + 2)];\n        int result = 0;\n\n        for (int i = 1; i < end.Length; i++) {\n            for (end[i] = i; end[i] != 1 && end[i] != 89; end[i] = SquareDigitSum(end[i])) { }\n            if (end[i] == 89) result++;\n        }\n        for (int i = end.Length; i < limit; i++) {\n            if (end[SquareDigitSum(i)] == 89) result++;\n        }\n        return result;\n\n        int SquareDigitSum(int n) {\n            int sum = 0;\n            while (n > 0) {\n                int digit = n % 10;\n                sum += digit * digit;\n                n /= 10;\n            }\n            return sum;\n        }\n    }\n\n}"}
{"title": "Iterated digits squaring", "language": "C sharp from C", "task": "If you add the square of the digits of a Natural number (an integer bigger than zero), you always end with either 1 or 89:\n15 -> 26 -> 40 -> 16 -> 37 -> 58 -> 89\n7 -> 49 -> 97 -> 130 -> 10 -> 1\n\nAn example in Python:\n\n>>> step = lambda x: sum(int(d) ** 2 for d in str(x))\n>>> iterate = lambda x: x if x in [1, 89] else iterate(step(x))\n>>> [iterate(x) for x in xrange(1, 20)]\n[1, 89, 89, 89, 89, 89, 1, 89, 89, 1, 89, 89, 1, 89, 89, 89, 89, 89, 1]\n\n\n;Task:\n: Count how many number chains for integers 1 <= n < 100_000_000 end with a value 89.\nOr, for much less credit - (showing that your algorithm and/or language is slow):\n: Count how many number chains for integers 1 <= n < 1_000_000 end with a value 89.\n\nThis problem derives from the Project Euler problem 92.\n\nFor a quick algorithm for this task see the talk page\n\n\n;Related tasks:\n* [[Combinations with repetitions]]\n* [[Digital root]]\n* [[Digital root/Multiplicative digital root]]\n\n", "solution": "using System;\nusing System.Numerics;\n\nclass Program {\n\n  const int MaxPow = 301;\n  static int [] sq = {1, 4, 9, 16, 25, 36, 49, 64, 81};\n  static BigInteger [] sums;\n\n  static bool is89(int x) {\n    while (true) {\n      int s = 0, t;\n      do if ((t = (x % 10) - 1) >= 0) s += sq[t]; while ((x /= 10) > 0);\n      if (s == 89) return true;\n      if (s == 1) return false;\n      x = s;\n    }\n  }\n\n  static BigInteger count89(int n) {\n      BigInteger result = 0;\n      for (int i = n * 81; i > 0; i--) {\n        foreach (int s in sq) { if(s > i) break; sums[i] += sums[i - s]; }\n        if (is89(i)) result += sums[i];\n      }\n      return result;\n  }\n\n  static void Main(string[] args) {\n    BigInteger [] t = new BigInteger[2] {1, 0}; sums = new BigInteger[MaxPow * 81]; Array.Copy(t, sums, t.Length);\n    DateTime st = DateTime.Now;\n    for (int n = 1; n < MaxPow; n++) {\n      Console.Write(\"1->10^{0,-3}: {1}\\n\", n, count89(n));\n      if ((DateTime.Now - st).TotalSeconds > 6) break;\n    }\n    Console.WriteLine(\"{0} seconds elapsed.\", (DateTime.Now - st).TotalSeconds);\n  }\n}"}
{"title": "JSON", "language": "C sharp 3.0", "task": "Load a JSON string into a data structure.  \nAlso, create a new data structure and serialize it into JSON.\n\nUse objects and arrays (as appropriate for your language) \nand make sure your JSON is valid (https://jsonformatter.org).\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Web.Script.Serialization;\n\nclass Program\n{\n    static void Main()\n    {\n        var people = new Dictionary<string, object> {{\"1\", \"John\"}, {\"2\", \"Susan\"}};\n        var serializer = new JavaScriptSerializer();\n        \n        var json = serializer.Serialize(people);\n        Console.WriteLine(json);\n\n        var deserialized = serializer.Deserialize<Dictionary<string, object>>(json);\n        Console.WriteLine(deserialized[\"2\"]);\n\n        var jsonObject = serializer.DeserializeObject(@\"{ \"\"foo\"\": 1, \"\"bar\"\": [10, \"\"apples\"\"] }\");\n        var data = jsonObject as Dictionary<string, object>;\n        var array = data[\"bar\"] as object[];\n        Console.WriteLine(array[1]);\n    }\n}"}
{"title": "Jewels and stones", "language": "C sharp", "task": "Create a function which takes two string parameters: 'stones' and 'jewels' and returns an integer.\n\nBoth strings can contain any number of upper or lower case letters. However, in the case of 'jewels', all letters must be distinct.\n\nThe function should count (and return) how many 'stones' are 'jewels' or, in other words, how many letters in 'stones' are also letters in 'jewels'.\n\n\nNote that:\n:# Only letters in the ISO basic Latin alphabet i.e. 'A to Z' or 'a to z' need be considered. \n:# A lower case letter is considered to be different from its upper case equivalent for this purpose, i.e., 'a' != 'A'.\n:# The parameters do not need to have exactly the same names.\n:# Validating the arguments is unnecessary.  \n\nSo, for example, if passed \"aAAbbbb\" for 'stones' and \"aA\" for 'jewels', the function should return 3.\n\nThis task was inspired by this problem.\n\n\n\n", "solution": "using System;\nusing System.Linq;\n\npublic class Program\n{\n    public static void Main() {\n        Console.WriteLine(Count(\"aAAbbbb\", \"Aa\"));\n        Console.WriteLine(Count(\"ZZ\", \"z\"));\n    }\n\n    private static int Count(string stones, string jewels) {\n        var bag = jewels.ToHashSet();\n        return stones.Count(bag.Contains);\n    }\n}"}
{"title": "Julia set", "language": "C sharp|C# from Python", "task": "Task\nGenerate and draw a Julia set. \n\n\n;Related tasks\n*   Mandelbrot Set\n\n", "solution": "public struct CalculatedPoint\n        {\n            public int x;\n            public int y;\n            public int i;\n        }\n\n        static void MultiThreaded()\n        {\n            const int w = 800;\n            const int h = 600;\n            const int zoom = 1;\n            const int maxiter = 255;\n            const int moveX = 0;\n            const int moveY = 0;\n            const double cX = -0.7;\n            const double cY = 0.27015;\n\n            // Precalculate a pallette of 256 colors\n            var colors = (from c in Enumerable.Range(0, 256)\n                          select Color.FromArgb((c >> 5) * 36, (c >> 3 & 7) * 36, (c & 3) * 85)).ToArray();\n\n            // The \"AsParallel\" below invokes PLINQ, making evaluation parallel using as many cores as\n            // are available.\n            var calculatedPoints = Enumerable.Range(0, w * h).AsParallel().Select(xy =>\n              {\n                  double zx, zy, tmp;\n                  int x, y;\n                  int i = maxiter;\n                  y = xy / w;\n                  x = xy % w;\n                  zx = 1.5 * (x - w / 2) / (0.5 * zoom * w) + moveX;\n                  zy = 1.0 * (y - h / 2) / (0.5 * zoom * h) + moveY;\n                  while (zx * zx + zy * zy < 4 && i > 1)\n                  {\n                      tmp = zx * zx - zy * zy + cX;\n                      zy = 2.0 * zx * zy + cY;\n                      zx = tmp;\n                      i -= 1;\n                  }\n                  return new CalculatedPoint { x = x, y = y, i = i };\n              });\n\n            // Bitmap is not multi-threaded, so main thread needs to read in the results as they\n            // come in and plot the pixels.\n            var bitmap = new Bitmap(w, h);\n            foreach (CalculatedPoint cp in calculatedPoints)\n                bitmap.SetPixel(cp.x, cp.y, colors[cp.i]);\n            bitmap.Save(\"julia-set-multi.png\");\n        }"}
{"title": "Jump anywhere", "language": "C sharp|C#", "task": "Imperative programs like to jump around, but some languages restrict these jumps. Many structured languages restrict their [[conditional structures]] and [[loops]] to ''local jumps'' within a function. Some assembly languages limit certain jumps or branches to a small range.\n\nThis task is to demonstrate a local jump and a global jump and the various other types of jumps that the language supports. \nFor the purpose of this task, the jumps need not be used for a single purpose and you have the freedom to use these jumps for different purposes. \nYou may also defer to more specific tasks, like [[Exceptions]] or [[Generator]]. \nThis task provides a \"grab bag\" for several types of jumps. There are ''non-local jumps'' across function calls, or ''long jumps'' to anywhere within a program. Anywhere means not only to the tops of functions!\n\n* Some languages can ''go to'' any global label in a program.\n* Some languages can break multiple function calls, also known as ''unwinding the call stack''.\n* Some languages can save a ''continuation''. The program can later continue from the same place. So you can jump anywhere, but only if you have a previous visit there (to save the continuation).\n\nThese jumps are not all alike. \nA simple ''goto'' never touches the call stack. \nA continuation saves the call stack, so you can continue a function call after it ends.\n\n\n;Task:\nUse your language to demonstrate the various types of jumps that it supports. \n\nBecause the possibilities vary by language, this task is not specific. \nYou have the freedom to use these jumps for different purposes. \nYou may also defer to more specific tasks, like [[Exceptions]] or [[Generator]].\n\n", "solution": "public int M(int n) {\n    int result = 0;\n    switch (n) {\n        case 1:\n            cost += 25;\n            break;\n        case 2:\n            cost += 25;\n            goto case 1;\n        case 3:\n            cost += 50;\n            goto case 1;\n    }\n    return result;\n}"}
{"title": "Kaprekar numbers", "language": "C sharp", "task": "A positive integer is a Kaprekar number if:\n* It is   '''1'''     (unity)\n* The decimal representation of its square may be split once into two parts consisting of positive integers which sum to the original number. \nNote that a split resulting in a part consisting purely of 0s is not valid, \nas 0 is not considered positive.\n\n\n;Example Kaprekar numbers:\n* 2223 is a Kaprekar number, as 2223 * 2223 = 4941729, 4941729 may be split to 494 and 1729, and 494 + 1729 = 2223.\n* The series of Kaprekar numbers is known as A006886, and begins as 1, 9, 45, 55, ....\n\n\n;Example process:\n10000 (1002) splitting from left to right:\n* The first split is [1, 0000], and is invalid; the 0000 element consists entirely of 0s, and 0 is not considered positive.\n* Slight optimization opportunity: When splitting from left to right, once the right part consists entirely of 0s, no further testing is needed; all further splits would also be invalid.\n\n\n;Task:\nGenerate and show all Kaprekar numbers less than 10,000. \n\n\n;Extra credit:\nOptionally, count (and report the count of) how many Kaprekar numbers are less than 1,000,000.\n\n\n;Extra extra credit:\nThe concept of Kaprekar numbers is not limited to base 10 (i.e. decimal numbers); \nif you can, show that Kaprekar numbers exist in other bases too.  \n\n\nFor this purpose, do the following:\n* Find all Kaprekar numbers for base 17 between 1 and 1,000,000 (one million);\n* Display each of them in base 10 representation;\n* Optionally, using base 17 representation (use letters 'a' to 'g' for digits 10(10) to 16(10)), display each of the numbers, its square, and where to split the square. \n \nFor example, 225(10) is \"d4\" in base 17, its square \"a52g\", and a5(17) + 2g(17) = d4(17), so the display would be something like:225   d4  a52g  a5 + 2g\n\n\n;Reference:\n* The Kaprekar Numbers by Douglas E. Iannucci (2000). PDF version\n\n\n;Related task:\n*   [[Casting out nines]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\npublic class KaprekarNumbers {\n\n    /// <summary>\n    /// The entry point of the program, where the program control starts and ends.\n    /// </summary>\n    public static void Main() {\n        int count = 0;\n\n        foreach ( ulong i in _kaprekarGenerator(999999) ) {\n            Console.WriteLine(i);\n            count++;\n        }\n\n        Console.WriteLine(\"There are {0} Kaprekar numbers less than 1000000.\", count);\n    }\n\n    /// <summary>\n    /// Generator function which generates the Kaprekar numbers.\n    /// </summary>\n    /// <returns>The generator.</returns>\n    /// <param name=\"max\">The maximum value of the numbers generated.</param>\n    private static IEnumerable<ulong> _kaprekarGenerator(ulong max) {\n\n        ulong next = 1;\n\n        // 1 is always a Kaprekar number.\n        yield return next;\n\n        for ( next = 2; next <= max; next++ ) {\n\n            ulong square = next * next;\n\n            for ( ulong check = 10; check <= 10000000000000000000; check *= 10 ) {\n                // Check the square against each power of 10 from 10^1 to 10^19 (highest which can be\n                // represented by a ulong)\n\n                // If the power of 10 to be checked against is greater than or equal to the square, stop checking\n                if ( square <= check )\n                    break;\n\n                // Given a power of 10 as 10^n, the remainder when dividing the square number by that power\n                // of 10 is equal to the last n digits of the number (starting from the right) and the\n                // quotient gives the remaining digits.\n                // If the last n digits are all zeroes, then the remainder will be zero, which is not\n                // accepted.\n\n                ulong r = square % check;\n                ulong q = (square - r) / check;\n\n                if ( r != 0 && q + r == next ) {\n                    yield return next;\n                    break;\n                }\n            }\n\n        }\n\n    }\n\n}"}
{"title": "Kernighans large earthquake problem", "language": "C sharp", "task": "Brian Kernighan, in a lecture at the University of Nottingham, described a problem on which this task is based.\n\n;Problem:\nYou are given a a data file of thousands of lines; each of three `whitespace` separated fields: a date, a one word name and the magnitude of the event.\n\nExample lines from the file would be lines like:\n8/27/1883    Krakatoa            8.8\n5/18/1980    MountStHelens       7.6\n3/13/2009    CostaRica           5.1\n\n;Task:\n* Create a program or script invocation to find all the events with magnitude greater than 6\n* Assuming an appropriate name e.g. \"data.txt\" for the file:\n:# Either: Show how your program is invoked to process a data file of that name.\n:# Or: Incorporate the file name into the program, (as it is assumed that the program is single use).\n\n", "solution": "using System;\nusing System.IO;\nusing System.Linq;\nusing System.Collections.Generic;\n\npublic class Program\n{\n    static void Main() {\n        foreach (var earthquake in LargeEarthquakes(\"data.txt\", 6))\n            Console.WriteLine(string.Join(\" \", earthquake));\n    }\n\n    static IEnumerable<string[]> LargeEarthquakes(string filename, double limit) =>\n        from line in File.ReadLines(filename)\n        let parts = line.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries)\n        where double.Parse(parts[2]) > limit\n        select parts;\n\n}"}
{"title": "Keyboard input/Obtain a Y or N response", "language": "C sharp", "task": "Obtain a valid   '''Y'''   or   '''N'''   response from the [[input device::keyboard]]. \n\nThe keyboard should be flushed, so that any outstanding key-presses are removed, preventing any existing   '''Y'''   or   '''N'''   key-press from being evaluated. \n\nThe response should be obtained as soon as   '''Y'''   or   '''N'''   are pressed, and there should be no need to press an   enter   key.\n\n", "solution": "using System;\n\nnamespace Y_or_N\n{\n    class Program\n    {\n        static void Main()\n        {\n            bool response = GetYorN();\n        }\n\n        static bool GetYorN()\n        {\n            ConsoleKey response; // Creates a variable to hold the user's response.\n\n            do\n            {\n                while (Console.KeyAvailable) // Flushes the input queue.\n                    Console.ReadKey();\n\n                Console.Write(\"Y or N? \"); // Asks the user to answer with 'Y' or 'N'.\n                response = Console.ReadKey().Key; // Gets the user's response.\n                Console.WriteLine(); // Breaks the line.\n            } while (response != ConsoleKey.Y && response != ConsoleKey.N); // If the user did not respond with a 'Y' or an 'N', repeat the loop.\n\n             /* \n              * Return true if the user responded with 'Y', otherwise false.\n              * \n              * We know the response was either 'Y' or 'N', so we can assume \n              * the response is 'N' if it is not 'Y'.\n              */\n            return response == ConsoleKey.Y;\n        }\n    }\n}"}
{"title": "Knight's tour", "language": "C sharp", "task": "Task\nProblem: you have a standard 8x8 chessboard, empty but for a single knight on some square.   Your task is to emit a series of legal knight moves that result in the knight visiting every square on the chessboard exactly once. Note that it is ''not'' a requirement that the tour be \"closed\"; that is, the knight need not end within a single move of its start position.\n\nInput and output may be textual or graphical, according to the conventions of the programming environment.  If textual, squares should be indicated in algebraic notation.  The output should indicate the order in which the knight visits the squares, starting with the initial position.  The form of the output may be a diagram of the board with the squares numbered according to visitation sequence, or a textual list of algebraic coordinates in order, or even an actual animation of the knight moving around the chessboard.\n\nInput: starting square\n\nOutput: move sequence\n\n\n;Related tasks\n* [[A* search algorithm]]\n* [[N-queens problem]]\n* [[Solve a Hidato puzzle]]\n* [[Solve a Holy Knight's tour]]\n* [[Solve a Hopido puzzle]]\n* [[Solve a Numbrix puzzle]]\n* [[Solve the no connection puzzle]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace prog\n{\n\tclass MainClass\n\t{\t\n\t\tconst int N = 8;\n\t\t\n\t\treadonly static int[,] moves = { {+1,-2},{+2,-1},{+2,+1},{+1,+2},\n\t\t\t                         {-1,+2},{-2,+1},{-2,-1},{-1,-2} };\n\t\tstruct ListMoves\n\t\t{\n\t\t\tpublic int x, y;\t\t\t\n\t\t\tpublic ListMoves( int _x, int _y ) { x = _x; y = _y; }\n\t\t}\t\t\n\t\t\n\t\tpublic static void Main (string[] args)\n\t\t{\n\t\t\tint[,] board = new int[N,N];\n\t\t\tboard.Initialize();\n\t\t\t\n\t\t\tint x = 0,\t\t\t\t\t\t// starting position\n\t\t\t    y = 0;\n\t\t\t\n\t\t\tList<ListMoves> list = new List<ListMoves>(N*N);\n\t\t\tlist.Add( new ListMoves(x,y) );\n\t\t\t\t\t\t\n\t\t\tdo\n\t\t\t{\t\t\t\t\t\t\t\t\n\t\t\t\tif ( Move_Possible( board, x, y ) )\n\t\t\t\t{\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\tint move = board[x,y];\t\t\t\t\t\n\t\t\t\t\tboard[x,y]++;\n\t\t\t\t\tx += moves[move,0];\n\t\t\t\t\ty += moves[move,1];\t\t\t\n\t\t\t\t\tlist.Add( new ListMoves(x,y) );\t\t\t\t\t\t\t\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\t\t\t\t\t\n\t\t\t\t\tif ( board[x,y] >= 8 )\n\t\t\t\t\t{\t\t\t\t\t\t\n\t\t\t\t\t\tboard[x,y] = 0;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\tlist.RemoveAt(list.Count-1);\t\t\t\t\t\t\n\t\t\t\t\t\tif ( list.Count == 0 )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tConsole.WriteLine( \"No solution found.\" );\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\t\t\n\t\t\t\t\t\tx = list[list.Count-1].x;\n\t\t\t\t\t\ty = list[list.Count-1].y;\t\t\t\t\t\t\n\t\t\t\t\t}\n\t\t\t\t\tboard[x,y]++;\n\t\t\t\t}\t\t\t\t\n\t\t\t}\n\t\t\twhile( list.Count < N*N );\n\t\t\t\n\t\t\tint last_x = list[0].x,\n\t\t\t    last_y = list[0].y;\n\t\t\tstring letters = \"ABCDEFGH\";\n\t\t\tfor( int i=1; i<list.Count; i++ )\n\t\t\t{\t\t\t\t\n\t\t\t\tConsole.WriteLine( string.Format(\"{0,2}:  \", i) + letters[last_x] + (last_y+1) + \" - \" + letters[list[i].x] + (list[i].y+1) );\n\t\t\t\t\n\t\t\t\tlast_x = list[i].x;\n\t\t\t\tlast_y = list[i].y;\n\t\t\t}\n\t\t}\n\t\t\n\t\tstatic bool Move_Possible( int[,] board, int cur_x, int cur_y )\n\t\t{\t\t\t\n\t\t\tif ( board[cur_x,cur_y] >= 8 ) \n\t\t\t\treturn false;\n\t\t\t\n\t\t\tint new_x = cur_x + moves[board[cur_x,cur_y],0],\n\t\t\t    new_y = cur_y + moves[board[cur_x,cur_y],1];\n\t\t\t\n\t\t\tif ( new_x >= 0 && new_x < N && new_y >= 0 && new_y < N && board[new_x,new_y] == 0 )\n\t\t\t\treturn true;\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t}\n}"}
{"title": "Kolakoski sequence", "language": "C sharp|C# from Java", "task": "The natural numbers, (excluding zero); with the property that:\n: ''if you form a new sequence from the counts of runs of the same number in the first sequence, this new sequence is the same as the first sequence''.\n\n;Example:\nThis is ''not'' a Kolakoski sequence:\n1,1,2,2,2,1,2,2,1,2,...\nIts sequence of run counts, (sometimes called a run length encoding, (RLE); but a true RLE also gives the character that each run encodes), is calculated like this:\n\n: Starting from the leftmost number of the sequence we have 2 ones, followed by 3 twos, then 1 ones, 2 twos, 1 one, ...\n\nThe above gives the RLE of:\n2, 3, 1, 2, 1, ...\n\nThe original sequence is different from its RLE in this case. '''It would be the same for a true Kolakoski sequence'''.\n\n;Creating a Kolakoski sequence:\n\nLets start with the two numbers (1, 2) that we will cycle through; i.e. they will be used in this order: 1,2,1,2,1,2,....\n\n# We start the sequence s with the first item from the cycle c: 1\n# An index, k, into the, (expanding), sequence will step, or index through each item of the sequence s from the first, at its own rate. \nWe will arrange that the k'th item of s states how many ''times'' the ''last'' item of sshould appear at the end of s.\n\nWe started s with 1 and therefore s[k] states that it should appear only the 1 time.\n\nIncrement k\nGet the next item from c and append it to the end of sequence s. s will then become: 1, 2\nk was moved to the second item in the list and s[k] states that it should appear two times, so append another of the last item to the sequence s: 1, 2,2\nIncrement k\nAppend the next item from the cycle to the list: 1, 2,2, 1\nk is now at the third item in the list that states that the last item should appear twice so add another copy of the last item to the sequence s: 1, 2,2, 1,1\nincrement k\n\n...\n\n'''Note''' that the RLE of 1, 2, 2, 1, 1, ... begins 1, 2, 2 which is the beginning of the original sequence. The generation algorithm ensures that this will always be the case.\n\n;Task:\n# Create a routine/proceedure/function/... that given an initial ordered list/array/tuple etc of the natural numbers (1, 2), returns the next number from the list when accessed in a cycle.\n# Create another routine that when given the initial ordered list (1, 2) and the minimum length of the sequence  to generate; uses the first routine and the algorithm above, to generate at least the requested first members of the kolakoski sequence.\n# Create a routine that when given a sequence, creates the run length encoding of that sequence (as defined above) and returns the result of checking if sequence starts with the exact members of its RLE. (But ''note'', due to sampling, do not compare the last member of the RLE).\n# Show, on this page, (compactly), the first 20 members of the sequence generated from (1, 2)\n# Check the sequence againt its RLE.\n# Show, on this page, the first 20 members of the sequence generated from (2, 1)\n# Check the sequence againt its RLE.\n# Show, on this page, the first 30 members of the Kolakoski sequence generated from (1, 3, 1, 2)\n# Check the sequence againt its RLE.\n# Show, on this page, the first 30 members of the Kolakoski sequence generated from (1, 3, 2, 1)\n# Check the sequence againt its RLE.\n(There are rules on generating Kolakoski sequences from this method that are broken by the last example)\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\n\nnamespace KolakoskiSequence {\n    class Crutch {\n        public readonly int len;\n        public int[] s;\n        public int i;\n\n        public Crutch(int len) {\n            this.len = len;\n            s = new int[len];\n            i = 0;\n        }\n\n        public void Repeat(int count) {\n            for (int j = 0; j < count; j++) {\n                if (++i == len) return;\n                s[i] = s[i - 1];\n            }\n        }\n    }\n\n    static class Extension {\n        public static int NextInCycle(this int[] self, int index) {\n            return self[index % self.Length];\n        }\n\n        public static int[] Kolakoski(this int[] self, int len) {\n            Crutch c = new Crutch(len);\n\n            int k = 0;\n            while (c.i < len) {\n                c.s[c.i] = self.NextInCycle(k);\n                if (c.s[k] > 1) {\n                    c.Repeat(c.s[k] - 1);\n                }\n                if (++c.i == len) return c.s;\n                k++;\n            }\n            return c.s;\n        }\n\n        public static bool PossibleKolakoski(this int[] self) {\n            int[] rle = new int[self.Length];\n            int prev = self[0];\n            int count = 1;\n            int pos = 0;\n            for (int i = 1; i < self.Length; i++) {\n                if (self[i] == prev) {\n                    count++;\n                }\n                else {\n                    rle[pos++] = count;\n                    count = 1;\n                    prev = self[i];\n                }\n            }\n            // no point adding final 'count' to rle as we're not going to compare it anyway\n            for (int i = 0; i < pos; i++) {\n                if (rle[i] != self[i]) {\n                    return false;\n                }\n            }\n            return true;\n        }\n\n        public static string AsString(this int[] self) {\n            StringBuilder sb = new StringBuilder(\"[\");\n            int count = 0;\n            foreach (var item in self) {\n                if (count > 0) {\n                    sb.Append(\", \");\n                }\n                sb.Append(item);\n                count++;\n            }\n            return sb.Append(\"]\").ToString();\n        }\n    }\n\n    class Program {\n        static void Main(string[] args) {\n            int[][] ias = {\n                new int[]{1, 2},\n                new int[]{2, 1},\n                new int[]{1, 3, 1, 2},\n                new int[]{1, 3, 2, 1}\n            };\n            int[] lens = { 20, 20, 30, 30 };\n\n            for (int i = 0; i < ias.Length; i++) {\n                int len = lens[i];\n                int[] kol = ias[i].Kolakoski(len);\n\n                Console.WriteLine(\"First {0} members of the sequence by {1}: \", len, ias[i].AsString());\n                Console.WriteLine(kol.AsString());\n                Console.WriteLine(\"Possible Kolakoski sequence? {0}\", kol.PossibleKolakoski());\n                Console.WriteLine();\n            }\n        }\n    }\n}"}
{"title": "Kosaraju", "language": "C sharp|C#", "task": "{{wikipedia|Graph}}\n\n\nKosaraju's algorithm (also known as the Kosaraju-Sharir algorithm) is a linear time algorithm to find the strongly connected components of a directed graph. Aho, Hopcroft and Ullman credit it to an unpublished paper from 1978 by S. Rao Kosaraju. The same algorithm was independently discovered by Micha Sharir and published by him in 1981. It makes use of the fact that the transpose graph (the same graph with the direction of every edge reversed) has exactly the same strongly connected components as the original graph.\n\nFor this task consider the directed graph with these connections:\n  0 -> 1\n  1 -> 2\n  2 -> 0\n  3 -> 1,  3 -> 2,  3 -> 4\n  4 -> 3,  4 -> 5\n  5 -> 2,  5 -> 6\n  6 -> 5\n  7 -> 4, 7  -> 6, 7 -> 7\n\nAnd report the kosaraju strongly connected component for each node.\n\n;References:\n* The article on Wikipedia.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nclass Node\n{\n\tpublic enum Colors\n\t{\n\t\tBlack, White, Gray\n\t}\n\n\tpublic Colors color { get; set; }\n\tpublic int N { get; }\n\t\n\tpublic Node(int n)\n\t{\n\t\tN = n;\n\t\tcolor = Colors.White;\n\t}\n}\n\nclass Graph\n{\n\tpublic HashSet<Node> V { get; }\n\tpublic Dictionary<Node, HashSet<Node>> Adj { get; }\n\n\t/// <summary>\n\t/// Kosaraju's strongly connected components algorithm\n\t/// </summary>\n\tpublic void Kosaraju()\n\t{\n\t\tvar L = new HashSet<Node>();\n\n\t\tAction<Node> Visit = null;\n\t\tVisit = (u) =>\n\t\t{\n\t\t\tif (u.color == Node.Colors.White)\n\t\t\t{\n\t\t\t\tu.color = Node.Colors.Gray;\n\n\t\t\t\tforeach (var v in Adj[u])\n\t\t\t\t\tVisit(v);\n\n\t\t\t\tL.Add(u);\n\t\t\t}\n\t\t};\n\n\t\tAction<Node, Node> Assign = null;\n\t\tAssign = (u, root) =>\n\t\t{\n\t\t\tif (u.color != Node.Colors.Black)\n\t\t\t{\n\t\t\t\tif (u == root)\n\t\t\t\t\tConsole.Write(\"SCC: \");\n\n\t\t\t\tConsole.Write(u.N + \" \");\n\t\t\t\tu.color = Node.Colors.Black;\n\n\t\t\t\tforeach (var v in Adj[u])\n\t\t\t\t\tAssign(v, root);\n\n\t\t\t\tif (u == root)\n\t\t\t\t\tConsole.WriteLine();\n\t\t\t}\n\t\t};\n\n\t\tforeach (var u in V)\n\t\t\tVisit(u);\n\n\t\tforeach (var u in L)\n\t\t\tAssign(u, u);\n\t}\n}"}
{"title": "Lah numbers", "language": "C sharp|C# from D", "task": "Lah numbers, sometimes referred to as ''Stirling numbers of the third kind'', are coefficients of polynomial expansions expressing rising factorials in terms of falling factorials.\n\nUnsigned Lah numbers count the number of ways a set of '''n''' elements can be partitioned into '''k''' non-empty linearly ordered subsets.\n\nLah numbers are closely related to Stirling numbers of the first & second kinds, and may be derived from them.\n\nLah numbers obey the identities and relations:\n   L(n, 0), L(0, k) = 0   # for n, k > 0\n   L(n, n) = 1\n   L(n, 1) = n!\n   L(n, k) =           ( n! * (n - 1)! ) / ( k! * (k - 1)! ) / (n - k)!      # For unsigned Lah numbers\n      ''or''\n   L(n, k) = (-1)**n * ( n! * (n - 1)! ) / ( k! * (k - 1)! ) / (n - k)!      # For   signed Lah numbers\n\n;Task:\n:* Write a routine (function, procedure, whatever) to find '''unsigned Lah numbers'''. There are several methods to generate unsigned Lah numbers. You are free to choose the most appropriate for your language. If your language has a built-in, or easily, publicly available library implementation, it is acceptable to use that.\n\n:* Using the routine, generate and show here, on this page, a table (or triangle) showing the unsigned Lah numbers, '''L(n, k)''', up to '''L(12, 12)'''. it is optional to show the row / column for n == 0 and k == 0. It is optional to show places where L(n, k) == 0 (when k > n).\n\n:* If your language supports large integers, find and show here, on this page, the maximum value of '''L(n, k)''' where '''n == 100'''.\n\n\n;See also:\n\n:* '''Wikipedia - Lah number'''\n:* '''OEIS:A105278 - Unsigned Lah numbers'''\n:* '''OEIS:A008297 - Signed Lah numbers'''\n\n\n;Related Tasks:\n\n:* '''Stirling numbers of the first kind'''\n:* '''Stirling numbers of the second kind'''\n:* '''Bell numbers'''\n\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Numerics;\n\nnamespace LahNumbers {\n    class Program {\n        static BigInteger Factorial(BigInteger n) {\n            if (n == 0) return 1;\n            BigInteger res = 1;\n            while (n > 0) {\n                res *= n--;\n            }\n            return res;\n        }\n\n        static BigInteger Lah(BigInteger n, BigInteger k) {\n            if (k == 1) return Factorial(n);\n            if (k == n) return 1;\n            if (k > n) return 0;\n            if (k < 1 || n < 1) return 0;\n            return (Factorial(n) * Factorial(n - 1)) / (Factorial(k) * Factorial(k - 1)) / Factorial(n - k);\n        }\n\n        static void Main() {\n            Console.WriteLine(\"Unsigned Lah numbers: L(n, k):\");\n            Console.Write(\"n/k \");\n            foreach (var i in Enumerable.Range(0, 13)) {\n                Console.Write(\"{0,10} \", i);\n            }\n            Console.WriteLine();\n            foreach (var row in Enumerable.Range(0, 13)) {\n                Console.Write(\"{0,-3}\", row);\n                foreach (var i in Enumerable.Range(0, row + 1)) {\n                    var l = Lah(row, i);\n                    Console.Write(\"{0,11}\", l);\n                }\n                Console.WriteLine();\n            }\n            Console.WriteLine(\"\\nMaximum value from the L(100, *) row:\");\n            var maxVal = Enumerable.Range(0, 100).Select(a => Lah(100, a)).Max();\n            Console.WriteLine(maxVal);\n        }\n    }\n}"}
{"title": "Largest int from concatenated ints", "language": "C sharp|C#", "task": "Given a set of positive integers, write a function to order the integers in such a way that the concatenation of the numbers forms the largest possible integer and return this integer.\n\nUse the following two sets of integers as tests   and   show your program output here.\n\n:::::*   {1, 34, 3, 98, 9, 76, 45, 4}\n:::::*   {54, 546, 548, 60}\n\n\n;Possible algorithms:\n# A solution could be found by trying all combinations and return the best. \n# Another way to solve this is to note that in the best arrangement, for any two adjacent original integers '''X''' and '''Y''', the concatenation '''X''' followed by '''Y''' will be numerically greater than or equal to the concatenation '''Y''' followed by '''X.\n# Yet another way to solve this is to pad the integers to the same size by repeating the digits then sort using these repeated integers as a sort key.\n\n\n;See also:\n*   Algorithms: What is the most efficient way to arrange the given numbers to form the biggest number?\n*   Constructing the largest number possible by rearranging a list\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        var source1 = new int[] { 1, 34, 3, 98, 9, 76, 45, 4 };\n        var source2 = new int[] { 54, 546, 548, 60 };\n\n        var largest1 = LargestPossibleSequence(source1);\n        var largest2 = LargestPossibleSequence(source2);\n\n        Console.WriteLine(\"The largest possible integer from set 1 is: {0}\", largest1);\n        Console.WriteLine(\"The largest possible integer from set 2 is: {0}\", largest2);\n    }\n\n    static long LargestPossibleSequence(int[] ints)\n    {\n        return long.Parse(string.Join(\"\", ints.OrderBy(i => i, new IntConcatenationComparer()).Reverse()));\n    }\n}\n\nclass IntConcatenationComparer : IComparer<int>\n{\n    public int Compare(int x, int y)\n    {\n        var xy = int.Parse(x.ToString() + y.ToString());\n        var yx = int.Parse(y.ToString() + x.ToString());\n\n        return xy - yx;\n    }\n}\n"}
{"title": "Largest number divisible by its digits", "language": "C sharp|C#", "task": "Find the largest base 10 integer whose digits are all different,   and   is evenly divisible by each of its individual digits.\n\n\nThese numbers are also known as   '''Lynch-Bell numbers''',   numbers   '''n'''   such that the\n(base ten) digits are all different (and do not include zero)   and   '''n'''   is divisible by each of its individual digits. \n\n\n;Example:\n'''135'''   is evenly divisible by   '''1''',   '''3''',   and   '''5'''.\n\n\nNote that the digit zero (0) can not be in the number as integer division by zero is undefined. \n\nThe digits must all be unique so a base ten number will have at most '''9''' digits.\n\nFeel free to use analytics and clever algorithms to reduce the search space your example needs to visit, but it must do an actual search. (Don't just feed it the answer and verify it is correct.)\n\n\n;Stretch goal:\nDo the same thing for hexadecimal.\n\n\n;Related tasks:\n:*   gapful numbers.\n:*   palindromic gapful numbers. \n\n\n;Also see:\n:*   The OEIS sequence:   A115569: Lynch-Bell numbers. \n\n", "solution": "using System;\n\nclass Program {\n    static int gcd(int a, int b) { return b > 0 ? gcd(b, a % b) : a; }\n\n    // returns least common multiple of digits of x in base b\n    static int lcmd(long x, int b) {\n      int r = (int)(x % b), a; x /= b; while (x > 0) {\n        r = (r * (a = (int)(x % b))) / gcd(r, a); x /= b; } return r; }\n\n    static void Main(string[] args) {\n        var sw = System.Diagnostics.Stopwatch.StartNew();\n        long mx = 987654321; // all digits except zero\n             mx = 98764321; // omitting 5 because even numbers are lost\n             mx /= 10;     // 7 digs because 8 digs won't divide by 3\n        long skip = lcmd(mx, 10), i; bool nDup;\n        for (i = mx - mx % skip; ; i -= skip) {\n            var s = i.ToString().ToCharArray(); Array.Sort(s);\n            if (s[0] == '0') continue; // no zeros\n            nDup = true; // checking for duplicate digits or digit five\n            for (int j = 0, k = 1; k < s.Length; j = k++)\n                if (s[j] == s[k] || s[k] == '5') { nDup = false; break; }\n            if (nDup) break; } sw.Stop(); // found it\n        Console.Write(\"base 10 = {0} in {1} \u03bcs\\n\", i,\n          1000 * sw.Elapsed.TotalMilliseconds);\n        sw.Restart();\n        mx = 0xfedcba987654321;    // all 15 digits used, no zero\n        skip = lcmd(mx >> 4, 16); // digit one implied, so omit it\n        for (i = mx - mx % skip; ; i -= skip) {\n            var s = i.ToString(\"x\").ToCharArray(); Array.Sort(s);\n            if (s[0] == '0') continue; // no zeros\n            nDup = true; // checking for duplicate digits\n            for (int j = 0, k = 1; k < s.Length; j = k++)\n                if (s[j] == s[k]) { nDup = false; break; }\n            if (nDup) break; } sw.Stop(); // found it\n        Console.Write(\"base 16 = {0} in {1} ms\", i.ToString(\"x\"),\n          sw.Elapsed.TotalMilliseconds); } }"}
{"title": "Last Friday of each month", "language": "C sharp", "task": "Write a program or a script that returns the date of the last Fridays of each month of a given year. \n\nThe year may be given through any simple input method in your language (command line, std in, etc).\n\n\nExample of an expected output:\n./last_fridays 2012\n2012-01-27\n2012-02-24\n2012-03-30\n2012-04-27\n2012-05-25\n2012-06-29\n2012-07-27\n2012-08-31\n2012-09-28\n2012-10-26\n2012-11-30\n2012-12-28\n\n\n;Related tasks\n* [[Five weekends]]\n* [[Day of the week]]\n* [[Find the last Sunday of each month]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\n\nnamespace RosettaCode.LastFridaysOfYear\n{\n    internal static class Program\n    {\n        private static IEnumerable<DateTime> LastFridaysOfYear(int year)\n        {\n            for (var month = 1; month <= 12; month++)\n            {\n                var date = new DateTime(year, month, 1).AddMonths(1).AddDays(-1);\n                while (date.DayOfWeek != DayOfWeek.Friday)\n                {\n                    date = date.AddDays(-1);\n                }\n                yield return date;\n            }\n        }\n\n        private static void Main(string[] arguments)\n        {\n            int year;\n            var argument = arguments.FirstOrDefault();\n            if (string.IsNullOrEmpty(argument) || !int.TryParse(argument, out year))\n            {\n                year = DateTime.Today.Year;\n            }\n\n            foreach (var date in LastFridaysOfYear(year))\n            {\n                Console.WriteLine(date.ToString(\"d\", CultureInfo.InvariantCulture));\n            }\n        }\n    }\n}"}
{"title": "Last letter-first letter", "language": "C sharp", "task": "A certain children's game involves starting with a word in a particular category.   Each participant in turn says a word, but that word must begin with the final letter of the previous word.   Once a word has been given, it cannot be repeated.   If an opponent cannot give a word in the category, they fall out of the game. \n\n\nFor example, with   \"animals\"   as the category,\n\nChild 1: dog \nChild 2: goldfish\nChild 1: hippopotamus\nChild 2: snake\n...\n\n\n\n;Task:\nTake the following selection of 70 English Pokemon names   (extracted from   Wikipedia's list of Pokemon)   and generate the/a sequence with the highest possible number of Pokemon names where the subsequent name starts with the final letter of the preceding name. \n\nNo Pokemon name is to be repeated.\n\n\naudino bagon baltoy banette bidoof braviary bronzor carracosta charmeleon\ncresselia croagunk darmanitan deino emboar emolga exeggcute gabite\ngirafarig gulpin haxorus heatmor heatran ivysaur jellicent jumpluff kangaskhan\nkricketune landorus ledyba loudred lumineon lunatone machamp magnezone mamoswine\nnosepass petilil pidgeotto pikachu pinsir poliwrath poochyena porygon2\nporygonz registeel relicanth remoraid rufflet sableye scolipede scrafty seaking\nsealeo silcoon simisear snivy snorlax spoink starly tirtouga trapinch treecko\ntyrogue vigoroth vulpix wailord wartortle whismur wingull yamask\n\n\n\nExtra brownie points for dealing with the full list of   646   names.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace ConsoleApplication1\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            string pokemon_names = @\"audino bagon baltoy banette bidoof braviary bronzor carracosta charmeleon\ncresselia croagunk darmanitan deino emboar emolga exeggcute gabite\ngirafarig gulpin haxorus heatmor heatran ivysaur jellicent jumpluff kangaskhan\nkricketune landorus ledyba loudred lumineon lunatone machamp magnezone mamoswine\nnosepass petilil pidgeotto pikachu pinsir poliwrath poochyena porygon2\nporygonz registeel relicanth remoraid rufflet sableye scolipede scrafty seaking\nsealeo silcoon simisear snivy snorlax spoink starly tirtouga trapinch treecko\ntyrogue vigoroth vulpix wailord wartortle whismur wingull yamask\";\n\n            string[] pokemon = pokemon_names.Split(new char[]{' ','\\n'});\n            List<string> chain = new List<string>(pokemon.Length);\n\n            for (int i = 0; i < pokemon.Length; i++)\n            {\n                swap(ref pokemon[0], ref pokemon[i]);\n                Search( pokemon, chain, 1 );               \n                swap(ref pokemon[0], ref pokemon[i]);\n            }\n\n            foreach (string s in chain)\n                Console.WriteLine(s);\n\n            Console.ReadKey();\n        }\n\n        static void Search(string[] pokemon, List<string> longest_chain, int len )\n        {\n            if (len > longest_chain.Count)\n            {\n                longest_chain.Clear();\n                for (int i = 0; i < len; i++)\n                    longest_chain.Add(pokemon[i]);\n            }\n\n            char lastchar = pokemon[len - 1][pokemon[len-1].Length - 1];\n            for (int i = len; i < pokemon.Length; i++)\n            {\n                if (pokemon[i][0] == lastchar)\n                {\n                    swap(ref pokemon[i], ref pokemon[len]);\n                    Search(pokemon, longest_chain, len + 1);\n                    swap(ref pokemon[i], ref pokemon[len]);\n                }\n            }\n        }\n\n        static void swap(ref string s1, ref string s2)\n        {\n            string tmp = s1;\n            s1 = s2;\n            s2 = tmp;\n        }\n    }\n}"}
{"title": "Latin Squares in reduced form", "language": "C sharp|C# from D", "task": "A Latin Square is in its reduced form if the first row and first column contain items in their natural order. The order n is the number of items. For any given n there is a set of reduced Latin Squares whose size increases rapidly with n. g is a number which identifies a unique element within the set of reduced Latin Squares of order n. The objective of this task is to construct the set of all Latin Squares of a given order and to provide a means which given suitable values for g any element within the set may be obtained.\n\nFor a reduced Latin Square the first row is always 1 to n. The second row is all [[Permutations/Derangements]] of 1 to n starting with 2. The third row is all [[Permutations/Derangements]] of 1 to n starting with 3 which do not clash (do not have the same item in any column) with row 2. The fourth row is all [[Permutations/Derangements]] of 1 to n starting with 4 which do not clash with rows 2 or 3. Likewise continuing to the nth row.\n\nDemonstrate by:\n* displaying the four reduced Latin Squares of order 4.\n* for n = 1 to 6 (or more) produce the set of reduced Latin Squares; produce a table which shows the size of the set of reduced Latin Squares and compares this value times n! times (n-1)! with the values in OEIS A002860.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace LatinSquares {\n    using matrix = List<List<int>>;\n\n    class Program {\n        static void Swap<T>(ref T a, ref T b) {\n            var t = a;\n            a = b;\n            b = t;\n        }\n\n        static matrix DList(int n, int start) {\n            start--; // use 0 basing\n            var a = Enumerable.Range(0, n).ToArray();\n            a[start] = a[0];\n            a[0] = start;\n            Array.Sort(a, 1, a.Length - 1);\n            var first = a[1];\n            // recursive closure permutes a[1:]\n            matrix r = new matrix();\n            void recurse(int last) {\n                if (last == first) {\n                    // bottom of recursion. you get here once for each permutation.\n                    // test if permutation is deranged.\n                    for (int j = 1; j < a.Length; j++) {\n                        var v = a[j];\n                        if (j == v) {\n                            return; //no, ignore it\n                        }\n                    }\n                    // yes, save a copy with 1 based indexing\n                    var b = a.Select(v => v + 1).ToArray();\n                    r.Add(b.ToList());\n                    return;\n                }\n                for (int i = last; i >= 1; i--) {\n                    Swap(ref a[i], ref a[last]);\n                    recurse(last - 1);\n                    Swap(ref a[i], ref a[last]);\n                }\n            }\n            recurse(n - 1);\n            return r;\n        }\n\n        static ulong ReducedLatinSquares(int n, bool echo) {\n            if (n <= 0) {\n                if (echo) {\n                    Console.WriteLine(\"[]\\n\");\n                }\n                return 0;\n            } else if (n == 1) {\n                if (echo) {\n                    Console.WriteLine(\"[1]\\n\");\n                }\n                return 1;\n            }\n\n            matrix rlatin = new matrix();\n            for (int i = 0; i < n; i++) {\n                rlatin.Add(new List<int>());\n                for (int j = 0; j < n; j++) {\n                    rlatin[i].Add(0);\n                }\n            }\n            // first row\n            for (int j = 0; j < n; j++) {\n                rlatin[0][j] = j + 1;\n            }\n\n            ulong count = 0;\n            void recurse(int i) {\n                var rows = DList(n, i);\n\n                for (int r = 0; r < rows.Count; r++) {\n                    rlatin[i - 1] = rows[r];\n                    for (int k = 0; k < i - 1; k++) {\n                        for (int j = 1; j < n; j++) {\n                            if (rlatin[k][j] == rlatin[i - 1][j]) {\n                                if (r < rows.Count - 1) {\n                                    goto outer;\n                                }\n                                if (i > 2) {\n                                    return;\n                                }\n                            }\n                        }\n                    }\n                    if (i < n) {\n                        recurse(i + 1);\n                    } else {\n                        count++;\n                        if (echo) {\n                            PrintSquare(rlatin, n);\n                        }\n                    }\n                outer: { }\n                }\n            }\n\n            //remaing rows\n            recurse(2);\n            return count;\n        }\n\n        static void PrintSquare(matrix latin, int n) {\n            foreach (var row in latin) {\n                var it = row.GetEnumerator();\n                Console.Write(\"[\");\n                if (it.MoveNext()) {\n                    Console.Write(it.Current);\n                }\n                while (it.MoveNext()) {\n                    Console.Write(\", {0}\", it.Current);\n                }\n                Console.WriteLine(\"]\");\n            }\n            Console.WriteLine();\n        }\n\n        static ulong Factorial(ulong n) {\n            if (n <= 0) {\n                return 1;\n            }\n            ulong prod = 1;\n            for (ulong i = 2; i < n + 1; i++) {\n                prod *= i;\n            }\n            return prod;\n        }\n\n        static void Main() {\n            Console.WriteLine(\"The four reduced latin squares of order 4 are:\\n\");\n            ReducedLatinSquares(4, true);\n\n            Console.WriteLine(\"The size of the set of reduced latin squares for the following orders\");\n            Console.WriteLine(\"and hence the total number of latin squares of these orders are:\\n\");\n            for (int n = 1; n < 7; n++) {\n                ulong nu = (ulong)n;\n\n                var size = ReducedLatinSquares(n, false);\n                var f = Factorial(nu - 1);\n                f *= f * nu * size;\n                Console.WriteLine(\"Order {0}: Size {1} x {2}! x {3}! => Total {4}\", n, size, n, n - 1, f);\n            }\n        }\n    }\n}"}
{"title": "Law of cosines - triples", "language": "C sharp", "task": "The Law of cosines states that for an angle g, (gamma) of any triangle, if the sides adjacent to the angle are A and B and the side opposite is C; then the lengths of the sides are related by this formula:\n           A2 + B2 - 2ABcos(g) = C2 \n\n;Specific angles:\nFor an angle of of   '''90o'''   this becomes the more familiar \"Pythagoras equation\":\n           A2 + B2  =  C2 \n\nFor an angle of   '''60o'''   this becomes the less familiar  equation:\n           A2 + B2 - AB  =  C2 \n\nAnd finally for an angle of   '''120o'''   this becomes the equation:\n           A2 + B2 + AB  =  C2 \n\n\n;Task:\n*   Find all integer solutions (in order) to the three specific cases, distinguishing between each angle being considered.\n*   Restrain all sides to the integers   '''1..13'''   inclusive.\n*   Show how many results there are for each of the three angles mentioned above.\n*   Display results on this page.\n\n\nNote: Triangles with the same length sides but different order are to be treated as the same. \n\n;Optional Extra credit:\n* How many 60deg integer triples are there for sides in the range 1..10_000 ''where the sides are not all of the same length''.\n\n\n;Related Task\n* [[Pythagorean triples]]\n\n\n;See also:\n* Visualising Pythagoras: ultimate proofs and crazy contortions Mathlogger Video\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing static System.Linq.Enumerable;\n\npublic static class LawOfCosinesTriples\n{\n    public static void Main2() {\n        PrintTriples(60, 13);\n        PrintTriples(90, 13);\n        PrintTriples(120, 13);\n        PrintTriples(60, 10_000, true, false);\n    }\n\n    private static void PrintTriples(int degrees, int maxSideLength, bool notAllTheSameLength = false, bool print = true) {\n        string s = $\"{degrees} degree triangles in range 1..{maxSideLength}\";\n        if (notAllTheSameLength) s += \" where not all sides are the same\";\n        Console.WriteLine(s);\n        int count = 0;\n        var triples = FindTriples(degrees, maxSideLength);\n        if (notAllTheSameLength) triples = triples.Where(NotAllTheSameLength);\n        foreach (var triple in triples) {\n            count++;\n            if (print) Console.WriteLine(triple);\n        }\n        Console.WriteLine($\"{count} solutions\");\n    }\n\n    private static IEnumerable<(int a, int b, int c)> FindTriples(int degrees, int maxSideLength) {\n        double radians = degrees * Math.PI / 180;\n        int coefficient = (int)Math.Round(Math.Cos(radians) * -2, MidpointRounding.AwayFromZero);\n        int maxSideLengthSquared = maxSideLength * maxSideLength;\n        return\n            from a in Range(1, maxSideLength)\n            from b in Range(1, a)\n            let cc = a * a + b * b + a * b * coefficient\n            where cc <= maxSideLengthSquared\n            let c = (int)Math.Sqrt(cc)\n            where c * c == cc\n            select (a, b, c);\n    }\n\n    private static bool NotAllTheSameLength((int a, int b, int c) triple) => triple.a != triple.b || triple.a != triple.c;\n}"}
{"title": "Least common multiple", "language": "C sharp|C#", "task": "Compute the   least common multiple   (LCM)   of two integers.\n\nGiven   ''m''   and   ''n'',   the least common multiple is the smallest positive integer that has both   ''m''   and   ''n''   as factors. \n\n\n;Example:\nThe least common multiple of   '''12'''   and   '''18'''   is   '''36''',       because:\n:*   '''12'''   is a factor     ('''12''' x '''3''' = '''36'''),     and \n:*   '''18'''   is a factor     ('''18''' x '''2''' = '''36'''),     and \n:*   there is no positive integer less than   '''36'''   that has both factors. \n\n\nAs a special case,   if either   ''m''   or   ''n''   is zero,   then the least common multiple is zero.\n\n\nOne way to calculate the least common multiple is to iterate all the multiples of   ''m'',   until you find one that is also a multiple of   ''n''.\n\nIf you already have   ''gcd''   for [[greatest common divisor]],   then this formula calculates   ''lcm''.\n\n\n:::: \\operatorname{lcm}(m, n) = \\frac{|m \\times n|}{\\operatorname{gcd}(m, n)}\n\n\nOne can also find   ''lcm''   by merging the [[prime decomposition]]s of both   ''m''   and   ''n''.\n\n\n;Related task\n:*   greatest common divisor.\n\n\n;See also:\n*   MathWorld entry:   Least Common Multiple.\n*   Wikipedia entry:   Least common multiple.\n\n", "solution": "Using System;\nclass Program\n{\n    static int gcd(int m, int n)\n    {\n        return n == 0 ? Math.Abs(m) : gcd(n, n % m);\n    }\n    static int lcm(int m, int n)\n    {\n        return Math.Abs(m * n) / gcd(m, n);\n    }\n    static void Main()\n    {\n        Console.WriteLine(\"lcm(12,18)=\" + lcm(12,18));\n    }\n}\n"}
{"title": "Left factorials", "language": "C sharp|C#", "task": "'''Left factorials''',   !n,   may refer to either   ''subfactorials''   or to   ''factorial sums''; \nthe same notation can be confusingly seen being used for the two different definitions.\n\nSometimes,   ''subfactorials''   (also known as ''derangements'')   may use any of the notations: \n:::::::*     !''n''`   \n:::::::*     !''n''  \n:::::::*     ''n''!  \n\n\n(It may not be visually obvious, but the last example uses an upside-down exclamation mark.)\n\n\nThis Rosetta Code task will be using this formula   (''factorial sums'')   for   '''left factorial''':\n\n:::::    !n = \\sum_{k=0}^{n-1} k! \n\n:::: where\n\n:::::   !0 = 0\n\n\n\n;Task\nDisplay the left factorials for:\n*   zero      through        ten     (inclusive)\n*   20   through   110          (inclusive)   by tens\n\n\nDisplay the length (in decimal digits) of the left factorials for:\n*   1,000   through   10,000   (inclusive), by thousands.\n\n\n;Also see:\n*   The OEIS entry: A003422 left factorials\n*   The MathWorld entry: left factorial\n*   The MathWorld entry: factorial sums\n*   The MathWorld entry: subfactorial\n\n\n;Related task:\n*   permutations/derangements (subfactorials)\n\n", "solution": "using System;\nusing System.Numerics;\n\nnamespace LeftFactorial\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            for (int i = 0; i <= 10; i++)\n            {\n                Console.WriteLine(string.Format(\"!{0} = {1}\", i, LeftFactorial(i)));\n            }\n\n            for (int j = 20; j <= 110; j += 10)\n            {\n                Console.WriteLine(string.Format(\"!{0} = {1}\", j, LeftFactorial(j)));\n            }\n\n            for (int k = 1000; k <= 10000; k += 1000)\n            {\n                Console.WriteLine(string.Format(\"!{0} has {1} digits\", k, LeftFactorial(k).ToString().Length));\n            }\n\n            Console.ReadKey();\n        }\n\n        private static BigInteger Factorial(int number)\n        {\n            BigInteger accumulator = 1;\n\n            for (int factor = 1; factor <= number; factor++)\n            {\n                accumulator *= factor;\n            }\n\n            return accumulator;\n        }\n\n        private static BigInteger LeftFactorial(int n)\n        {\n            BigInteger result = 0;\n\n            for (int i = 0; i < n; i++)\n            {\n                result += Factorial(i);\n            }\n\n            return result;\n        }\n    }\n}\n"}
{"title": "Levenshtein distance", "language": "C sharp|C#", "task": "{{Wikipedia}}\n\nIn information theory and computer science, the '''Levenshtein distance''' is a edit distance). The Levenshtein distance between two strings is defined as the minimum number of edits needed to transform one string into the other, with the allowable edit operations being insertion, deletion, or substitution of a single character. \n\n\n;Example:\nThe Levenshtein distance between \"'''kitten'''\" and \"'''sitting'''\" is 3, since the following three edits change one into the other, and there isn't a way to do it with fewer than three edits:\n::#   '''k'''itten    '''s'''itten       (substitution of 'k' with 's')\n::#   sitt'''e'''n    sitt'''i'''n       (substitution of 'e' with 'i')\n::#   sittin          sittin'''g'''      (insert 'g' at the end).\n\n\n''The Levenshtein distance between   \"'''rosettacode'''\",   \"'''raisethysword'''\"   is   '''8'''.\n\n''The distance between two strings is same as that when both strings are reversed.''\n\n\n;Task:\nImplements a Levenshtein distance function, or uses a library function, to show the Levenshtein distance between   \"kitten\"   and   \"sitting\". \n\n\n;Related task:\n*   [[Longest common subsequence]]\n\n\n\n", "solution": "using System;\n\nnamespace LevenshteinDistance\n{\n    class Program\n    {\n        static int LevenshteinDistance(string s, string t)\n        {\n            int n = s.Length;\n            int m = t.Length;\n            int[,] d = new int[n + 1, m + 1];\n\t\t\n\t    if (n == 0)\n\t    {\n\t\treturn m;\n\t    }\n\t\n\t    if (m == 0)\n\t    {\n\t\treturn n;\n\t    }\n\n            for (int i = 0; i <= n; i++)\n                d[i, 0] = i;\n            for (int j = 0; j <= m; j++)\n                d[0, j] = j;\n\t\t\t\n            for (int j = 1; j <= m; j++)\n                for (int i = 1; i <= n; i++)\n                    if (s[i - 1] == t[j - 1])\n                        d[i, j] = d[i - 1, j - 1];  //no operation\n                    else\n                        d[i, j] = Math.Min(Math.Min(\n                            d[i - 1, j] + 1,    //a deletion\n                            d[i, j - 1] + 1),   //an insertion\n                            d[i - 1, j - 1] + 1 //a substitution\n                            );\n            return d[n, m];\n        }\n\n        static void Main(string[] args)\n        {\n            if (args.Length == 2)\n                Console.WriteLine(\"{0} -> {1} = {2}\",\n                    args[0], args[1], LevenshteinDistance(args[0], args[1]));\n            else\n                Console.WriteLine(\"Usage:-\\n\\nLevenshteinDistance <string1> <string2>\");\n        }\n    }\n}"}
{"title": "Long year", "language": "C sharp", "task": "Most years have 52 weeks, some have 53, according to ISO8601.\n\n\n;Task:\nWrite a function which determines if a given year is long (53 weeks) or not, and demonstrate it.\n\n", "solution": "using static System.Console;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Globalization;\n\npublic static class Program\n{\n    public static void Main()\n    {\n        WriteLine(\"Long years in the 21st century:\");\n        WriteLine(string.Join(\" \", 2000.To(2100).Where(y => ISOWeek.GetWeeksInYear(y) == 53)));\n    }\n    \n    public static IEnumerable<int> To(this int start, int end) {\n        for (int i = start; i < end; i++) yield return i;\n    }\n    \n}"}
{"title": "Longest common subsequence", "language": "C sharp|C#", "task": "'''Introduction'''\n\nDefine a ''subsequence'' to be any output string obtained by deleting zero or more symbols from an input string.\n\nThe '''Longest Common Subsequence''' ('''LCS''') is a subsequence of maximum length common to two or more strings.\n\nLet ''A''  ''A''[0]... ''A''[m - 1] and ''B''  ''B''[0]... ''B''[n - 1], m < n be strings drawn from an alphabet S of size s, containing every distinct symbol in A + B.\n\nAn ordered pair (i, j) will be referred to as a match if ''A''[i] = ''B''[j], where 0 <= i < m and 0 <= j < n.\n\nThe set of matches '''M''' defines a relation over matches: '''M'''[i, j] = (i, j)  '''M'''.\n\nDefine a ''non-strict'' product-order (<=) over ordered pairs, such that (i1, j1) <= (i2, j2) = i1 <= i2 and j1 <= j2.  We define (>=) similarly.\n\nWe say ordered pairs p1 and p2 are ''comparable'' if either p1 <= p2 or p1 >= p2 holds.  If i1 < i2 and j2 < j1 (or i2 < i1 and j1 < j2) then neither p1 <= p2 nor p1 >= p2 are possible, and we say p1 and p2 are ''incomparable''.\n\nDefine the ''strict'' product-order (<) over ordered pairs, such that (i1, j1) < (i2, j2) = i1 < i2 and j1 < j2.  We define (>) similarly.\n\nA chain '''C''' is a subset of '''M''' consisting of at least one element m; and where either m1 < m2 or m1 > m2 for every pair of distinct elements m1 and m2.  An antichain '''D''' is any subset of '''M''' in which every pair of distinct elements m1 and m2 are incomparable.\n\nA chain can be visualized as a strictly increasing curve that passes through matches (i, j) in the m*n coordinate space of '''M'''[i, j].\n\nEvery Common Sequence of length ''q'' corresponds to a chain of cardinality ''q'', over the set of matches '''M'''.  Thus, finding an LCS can be restated as the problem of finding a chain of maximum cardinality ''p''.\n\nAccording to [Dilworth 1950], this cardinality ''p'' equals the minimum number of disjoint antichains into which '''M''' can be decomposed.  Note that such a decomposition into the minimal number p of disjoint antichains may not be unique.\n\n'''Background'''\n\nWhere the number of symbols appearing in matches is small relative to the length of the input strings, reuse of the symbols increases; and the number of matches will tend towards O(''m*n'') quadratic growth.  This occurs, for example, in the Bioinformatics application of nucleotide and protein sequencing.\n\nThe divide-and-conquer approach of [Hirschberg 1975] limits the space required to O(''n'').  However, this approach requires O(''m*n'') time even in the best case.\n\nThis quadratic time dependency may become prohibitive, given very long input strings.  Thus, heuristics are often favored over optimal Dynamic Programming solutions.\n\nIn the application of comparing file revisions, records from the input files form a large symbol space; and the number of symbols approaches the length of the LCS.  In this case the number of matches reduces to linear, O(''n'') growth.\n\nA binary search optimization due to [Hunt and Szymanski 1977] can be applied to the basic Dynamic Programming approach, resulting in an expected performance of O(''n log m'').  Performance can degrade to O(''m*n log m'') time in the worst case, as the number of matches grows to O(''m*n'').\n\n'''Note'''\n\n[Rick 2000] describes a linear-space algorithm with a time bound of O(''n*s + p*min(m, n - p)'').\n\n'''Legend'''\n\n A, B are input strings of lengths m, n respectively\n p is the length of the LCS\n M is the set of matches (i, j) such that A[i] = B[j]\n r is the magnitude of M\n s is the magnitude of the alphabet S of distinct symbols in A + B\n\n'''References'''\n\n[Dilworth 1950] \"A decomposition theorem for partially ordered sets\"\nby Robert P. Dilworth, published January 1950,\nAnnals of Mathematics [Volume 51, Number 1, ''pp.'' 161-166]\n\n[Goeman and Clausen 2002] \"A New Practical Linear Space Algorithm for the Longest Common\nSubsequence Problem\" by Heiko Goeman and Michael Clausen,\npublished 2002, Kybernetika [Volume 38, Issue 1, ''pp.'' 45-66]\n\n[Hirschberg 1975] \"A linear space algorithm for computing maximal common subsequences\"\nby Daniel S. Hirschberg, published June 1975\nCommunications of the ACM [Volume 18, Number 6, ''pp.'' 341-343]\n\n[Hunt and McIlroy 1976] \"An Algorithm for Differential File Comparison\"\nby James W. Hunt and M. Douglas McIlroy, June 1976\nComputing Science Technical Report, Bell Laboratories 41\n\n[Hunt and Szymanski 1977] \"A Fast Algorithm for Computing Longest Common Subsequences\"\nby James W. Hunt and Thomas G. Szymanski, published May 1977\nCommunications of the ACM [Volume 20, Number 5, ''pp.'' 350-353]\n\n[Rick 2000] \"Simple and fast linear space computation of longest common subsequences\"\nby Claus Rick, received 17 March 2000, Information Processing Letters,\nElsevier Science [Volume 75, ''pp.'' 275-281]\n\n\n'''Examples'''\n\nThe sequences \"1234\" and \"1224533324\" have an LCS of \"1234\":\n '''1234'''\n '''12'''245'''3'''332'''4'''\n\nFor a string example, consider the sequences \"thisisatest\" and \"testing123testing\". An LCS would be \"tsitest\":\n '''t'''hi'''si'''sa'''test'''\n '''t'''e'''s'''t'''i'''ng123'''test'''ing\n\nIn this puzzle, your code only needs to deal with strings. Write a function which returns an LCS of two strings (case-sensitive). You don't need to show multiple LCS's.\n\nFor more information on this problem please see Wikipedia.\n\n\n", "solution": "using System;\n\nnamespace LCS\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            string word1 = \"thisisatest\";\n            string word2 = \"testing123testing\";\n            \n            Console.WriteLine(lcsBack(word1, word2));\n            Console.ReadKey();\n        }\n\n        public static string lcsBack(string a, string b)\n        {\n            string aSub = a.Substring(0, (a.Length - 1 < 0) ? 0 : a.Length - 1);\n            string bSub = b.Substring(0, (b.Length - 1 < 0) ? 0 : b.Length - 1);\n            \n            if (a.Length == 0 || b.Length == 0)            \n                return \"\";\n            else if (a[a.Length - 1] == b[b.Length - 1])\n                return lcsBack(aSub, bSub) + a[a.Length - 1];\n            else\n            {\n                string x = lcsBack(a, bSub);\n                string y = lcsBack(aSub, b);\n                return (x.Length > y.Length) ? x : y;\n            }\n        }\n    }\n}"}
{"title": "Longest common substring", "language": "C sharp|C#", "task": "Write a function that returns the longest common substring of two strings. \n\nUse it within a program that demonstrates sample output from the function, which will consist of the longest common substring between \"thisisatest\" and \"testing123testing\". \n\nNote that substrings are consecutive characters within a string.   This distinguishes them from subsequences, which is any sequence of characters within a string, even if there are extraneous characters in between them. \n\nHence, the [[longest common subsequence]] between \"thisisatest\" and \"testing123testing\" is \"tsitest\", whereas the longest common sub''string'' is just \"test\".\n\n\n\n\n;References:\n*Generalize Suffix Tree\n*[[Ukkonen's Suffix Tree Construction]]\n\n", "solution": "using System;\n\nnamespace LongestCommonSubstring\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            Console.WriteLine(lcs(\"thisisatest\", \"testing123testing\"));\n            Console.ReadKey(true);\n        }\n\n        public static string lcs(string a, string b)\n        {\n            var lengths = new int[a.Length, b.Length];\n            int greatestLength = 0;\n            string output = \"\";\n            for (int i = 0; i < a.Length; i++)\n            {\n                for (int j = 0; j < b.Length; j++)\n                {\n                    if (a[i] == b[j])\n                    {\n                        lengths[i, j] = i == 0 || j == 0 ? 1 : lengths[i - 1, j - 1] + 1;\n                        if (lengths[i, j] > greatestLength)\n                        {\n                            greatestLength = lengths[i, j];\n                            output = a.Substring(i - greatestLength + 1, greatestLength);\n                        }\n                    }\n                    else\n                    {\n                        lengths[i, j] = 0;\n                    }\n                }\n            }\n            return output;\n        }\n    }\n}"}
{"title": "Longest common substring", "language": "C sharp|C# from REXX", "task": "Write a function that returns the longest common substring of two strings. \n\nUse it within a program that demonstrates sample output from the function, which will consist of the longest common substring between \"thisisatest\" and \"testing123testing\". \n\nNote that substrings are consecutive characters within a string.   This distinguishes them from subsequences, which is any sequence of characters within a string, even if there are extraneous characters in between them. \n\nHence, the [[longest common subsequence]] between \"thisisatest\" and \"testing123testing\" is \"tsitest\", whereas the longest common sub''string'' is just \"test\".\n\n\n\n\n;References:\n*Generalize Suffix Tree\n*[[Ukkonen's Suffix Tree Construction]]\n\n", "solution": "//C# program tests the LCSUBSTR (Longest Common Substring) subroutine.\nusing System;\nnamespace LongestCommonSubstring\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            string a = args.Length >= 1 ? args[0] : \"\";                                             /*get two arguments (strings).   */\n            string b = args.Length == 2 ? args[1] : \"\";\n            if (a == \"\") a = \"thisisatest\";                                                         /*use this string for a default. */\n            if (b == \"\") b = \"testing123testing\";                                                   /* \"    \"     \"    \"  \"    \"     */\n            Console.WriteLine(\"string A = {0}\", a);                                                 /*echo string  A  to screen.     */\n            Console.WriteLine(\"string B = {0}\", b);                                                 /*echo string  B  to screen.     */\n            Console.WriteLine(\"LCsubstr = {0}\", LCsubstr(a, b));                                    /*tell Longest Common Substring. */\n            Console.ReadKey(true);\n        }                                                                                           /*stick a fork in it, we're done.*/\n\n        /*\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500LCSUBSTR subroutine\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500*/\n        public static string LCsubstr(string x, string y)                                           /*Longest Common Substring.      */\n        {\n            string output = \"\";\n            int lenx = x.Length;                                                                    /*shortcut for using the X length*/\n            for (int j = 0; j < lenx; j++)                                                          /*step through start points in X.*/\n            {\n                for (int k = lenx - j; k > -1; k--)                                                 /*step through string lengths.   */\n                {\n                    string common = x.Substring(j, k);                                              /*extract a common substring.    */\n                    if (y.IndexOf(common) > -1 && common.Length > output.Length) output = common;   /*longest?*/\n                }                                                                                   /*k*/\n            }                                                                                       /*j*/\n            return output;                                                                          /*$  is \"\" if no common string.  */\n        }\n    }\n}"}
{"title": "Longest common substring", "language": "C sharp|C# from zkl", "task": "Write a function that returns the longest common substring of two strings. \n\nUse it within a program that demonstrates sample output from the function, which will consist of the longest common substring between \"thisisatest\" and \"testing123testing\". \n\nNote that substrings are consecutive characters within a string.   This distinguishes them from subsequences, which is any sequence of characters within a string, even if there are extraneous characters in between them. \n\nHence, the [[longest common subsequence]] between \"thisisatest\" and \"testing123testing\" is \"tsitest\", whereas the longest common sub''string'' is just \"test\".\n\n\n\n\n;References:\n*Generalize Suffix Tree\n*[[Ukkonen's Suffix Tree Construction]]\n\n", "solution": "//C# program tests the LCS (Longest Common Substring) subroutine.\nusing System;\nnamespace LongestCommonSubstring\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            string a = args.Length >= 1 ? args[0] : \"\";                                             /*get two arguments (strings).   */\n            string b = args.Length == 2 ? args[1] : \"\";\n            if (a == \"\") a = \"thisisatest\";                                                         /*use this string for a default. */\n            if (b == \"\") b = \"testing123testing\";                                                   /* \"    \"     \"    \"  \"    \"     */\n            Console.WriteLine(\"string A = {0}\", a);                                                 /*echo string  A  to screen.     */\n            Console.WriteLine(\"string B = {0}\", b);                                                 /*echo string  B  to screen.     */\n            Console.WriteLine(\"LCS = {0}\", lcs(a, b));                                              /*tell Longest Common Substring. */\n            Console.ReadKey(true);\n        }                                                                                           /*stick a fork in it, we're done.*/\n\n        /*\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500LCS subroutine\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500*/\n        private static string lcs(string a, string b)\n        {\n           if(b.Length<a.Length){ string t=a; a=b; b=t; }\n           for (int n = a.Length; n > 0; n--)\n           {\n              for (int m = a.Length-n; m <= a.Length-n; m++)\n              {\n                  string s=a.Substring(m,n);\n                  if(b.Contains(s)) return(s);\n              }\n           }\n           return \"\";\n        }    \n    }\n"}
{"title": "Longest increasing subsequence", "language": "C sharp 6", "task": "Calculate and show here a longest increasing subsequence of the list:\n:\\{3, 2, 6, 4, 5, 1\\}\nAnd of the list:\n:\\{0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15\\}\n\nNote that a list may have more than one subsequence that is of the maximum length.\n\n\n\n;Ref:\n# Dynamic Programming #1: Longest Increasing Subsequence on YouTube\n# An efficient solution can be based on Patience sorting.\n\n", "solution": "using System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic static class LIS\n{\n    public static IEnumerable<T> FindRec<T>(IList<T> values, IComparer<T> comparer = null) =>\n        values == null ? throw new ArgumentNullException() :\n            FindRecImpl(values, Sequence<T>.Empty, 0, comparer ?? Comparer<T>.Default).Reverse();\n\n    private static Sequence<T> FindRecImpl<T>(IList<T> values, Sequence<T> current, int index, IComparer<T> comparer) {\n        if (index == values.Count) return current;\n        if (current.Length > 0 && comparer.Compare(values[index], current.Value) <= 0)\n            return FindRecImpl(values, current, index + 1, comparer);\n        return Max(\n            FindRecImpl(values, current, index + 1, comparer),\n            FindRecImpl(values, current + values[index], index + 1, comparer)\n        );\n    }\n\n    private static Sequence<T> Max<T>(Sequence<T> a, Sequence<T> b) => a.Length < b.Length ? b : a;\n\n    class Sequence<T> : IEnumerable<T>\n    {\n        public static readonly Sequence<T> Empty = new Sequence<T>(default(T), null);\n\n        public Sequence(T value, Sequence<T> tail)\n        {\n            Value = value;\n            Tail = tail;\n            Length = tail == null ? 0 : tail.Length + 1;\n        }\n\n        public T Value { get; }\n        public Sequence<T> Tail { get; }\n        public int Length { get; }\n\n        public static Sequence<T> operator +(Sequence<T> s, T value) => new Sequence<T>(value, s);\n\n        public IEnumerator<T> GetEnumerator()\n        {\n            for (var s = this; s.Length > 0; s = s.Tail) yield return s.Value;\n        }\n\n        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();\n    }\n}"}
{"title": "Longest increasing subsequence", "language": "C sharp 7", "task": "Calculate and show here a longest increasing subsequence of the list:\n:\\{3, 2, 6, 4, 5, 1\\}\nAnd of the list:\n:\\{0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15\\}\n\nNote that a list may have more than one subsequence that is of the maximum length.\n\n\n\n;Ref:\n# Dynamic Programming #1: Longest Increasing Subsequence on YouTube\n# An efficient solution can be based on Patience sorting.\n\n", "solution": "public static class LIS\n{\n    public static T[] Find<T>(IList<T> values, IComparer<T> comparer = null) {\n        if (values == null) throw new ArgumentNullException();\n        if (comparer == null) comparer = Comparer<T>.Default;\n        var pileTops = new List<T>();\n        var pileAssignments = new int[values.Count];\n        for (int i = 0; i < values.Count; i++) {\n            T element = values[i];\n            int pile = pileTops.BinarySearch(element, comparer);\n            if (pile < 0) pile = ~pile;\n            if (pile == pileTops.Count) pileTops.Add(element);\n            else pileTops[pile] = element;\n            pileAssignments[i] = pile;\n        }\n        T[] result = new T[pileTops.Count];\n        for (int i = pileAssignments.Length - 1, p = pileTops.Count - 1; p >= 0; i--) {\n            if (pileAssignments[i] == p) result[p--] = values[i];\n        }\n        return result;\n    }\n\n    public static void Main() {\n        Console.WriteLine(string.Join(\",\", LIS.Find(new [] { 3, 2, 6, 4, 5, 1 })));\n        Console.WriteLine(string.Join(\",\", LIS.Find(new [] { 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 })));\n    }\n}"}
{"title": "MAC vendor lookup", "language": "C sharp|C#", "task": "Every connected device around the world comes with a unique Media Access Control address, or a   MAC address. \n\nA common task a network administrator may come across is being able to identify a network device's manufacturer when given only a MAC address.\n\n\n;Task:\nInterface with one (or numerous) APIs that exist on the internet and retrieve the device manufacturer based on a supplied MAC address.\n\nA MAC address that does not return a valid result should return the String \"N/A\".   An error related to the network connectivity or the API should return a null result.\n\nMany implementations on this page use http://api.macvendors.com/ which, as of 19th September 2021, is throttling requests. After only 2 calls, the following response is returned for all subsequent requests. If you are planning to use the same provider or going to run the examples on this page, consider building in a delay between two calls.\n\n'''{\"errors\":{\"detail\":\"Too Many Requests\",\"message\":\"Please slow down your requests or upgrade your plan at https://macvendors.com\"}}'''\n\n", "solution": "using System;\nusing System.Net;\nusing System.Net.Http;\nusing System.Threading.Tasks;\n\nclass Program\n{\n    static async Task<string> LookupMac(string MacAddress)\n    {\n        var uri = new Uri(\"http://api.macvendors.com/\" + WebUtility.UrlEncode(MacAddress));\n        using (var wc = new HttpClient())\n            return await wc.GetStringAsync(uri);\n    }\n    static void Main(string[] args)\n    {\n        foreach (var mac in new string[] { \"88:53:2E:67:07:BE\", \"FC:FB:FB:01:FA:21\", \"D4:F4:6F:C9:EF:8D\" })\n            Console.WriteLine(mac + \"\\t\" + LookupMac(mac).Result);\n        Console.ReadLine();\n    }\n}"}
{"title": "MD4", "language": "C sharp|C#", "task": "Find the MD4 message digest of a string of [[octet]]s. \nUse the ASCII encoded string \"Rosetta Code\" (without quotes). \nYou may either call an MD4 library, or implement MD4 in your language.\n\n'''MD4''' is an obsolete hash function that computes a 128-bit message digest that sometimes appears in obsolete protocols.\n\nRFC 1320 specifies the MD4 algorithm. RFC 6150 declares that MD4 is obsolete.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nstatic class Md4\n{\n    public static string Md4Hash(this string input)\n    {\n        // get padded uints from bytes\n        List<byte> bytes = Encoding.ASCII.GetBytes(input).ToList();\n        uint bitCount = (uint)(bytes.Count) * 8;\n        bytes.Add(128);\n        while (bytes.Count % 64 != 56) bytes.Add(0);\n        var uints = new List<uint>();\n        for (int i = 0; i + 3 < bytes.Count; i += 4)\n            uints.Add(bytes[i] | (uint)bytes[i + 1] << 8 | (uint)bytes[i + 2] << 16 | (uint)bytes[i + 3] << 24);\n        uints.Add(bitCount);\n        uints.Add(0);\n\n        // run rounds\n        uint a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476;\n        Func<uint, uint, uint> rol = (x, y) => x << (int)y | x >> 32 - (int)y;\n        for (int q = 0; q + 15 < uints.Count; q += 16)\n        {\n            var chunk = uints.GetRange(q, 16);\n            uint aa = a, bb = b, cc = c, dd = d;\n            Action<Func<uint, uint, uint, uint>, uint[]> round = (f, y) =>\n            {\n                foreach (uint i in new[] { y[0], y[1], y[2], y[3] })\n                {\n                    a = rol(a + f(b, c, d) + chunk[(int)(i + y[4])] + y[12], y[8]);\n                    d = rol(d + f(a, b, c) + chunk[(int)(i + y[5])] + y[12], y[9]);\n                    c = rol(c + f(d, a, b) + chunk[(int)(i + y[6])] + y[12], y[10]);\n                    b = rol(b + f(c, d, a) + chunk[(int)(i + y[7])] + y[12], y[11]);\n                }\n            };\n            round((x, y, z) => (x & y) | (~x & z), new uint[] { 0, 4, 8, 12, 0, 1, 2, 3, 3, 7, 11, 19, 0 });\n            round((x, y, z) => (x & y) | (x & z) | (y & z), new uint[] { 0, 1, 2, 3, 0, 4, 8, 12, 3, 5, 9, 13, 0x5a827999 });\n            round((x, y, z) => x ^ y ^ z, new uint[] { 0, 2, 1, 3, 0, 8, 4, 12, 3, 9, 11, 15, 0x6ed9eba1 });\n            a += aa; b += bb; c += cc; d += dd;\n        }\n\n        // return hex encoded string\n        byte[] outBytes = new[] { a, b, c, d }.SelectMany(BitConverter.GetBytes).ToArray();\n        return BitConverter.ToString(outBytes).Replace(\"-\", \"\").ToLower();\n    }\n    static void Main() { Console.WriteLine(\"Rosetta Code\".Md4Hash()); }\n}"}
{"title": "Mad Libs", "language": "C sharp", "task": "{{wikipedia}}\n\n\nMad Libs is a phrasal template word game where one player prompts another for a list of words to substitute for blanks in a story, usually with funny results. \n\n\n;Task;\nWrite a program to create a Mad Libs like story. \n\nThe program should read an arbitrary multiline story from input.\n\nThe story will be terminated with a blank line. \n\nThen, find each replacement to be made within the story, ask the user for a word to replace it with, and make all the replacements.\n\nStop when there are none left and print the final story.\n\n\nThe input should be an arbitrary story in the form:\n\n went for a walk in the park. \nfound a .  decided to take it home.\n\nGiven this example, it should then ask for a name, a he or she and a noun ( gets replaced both times with the same value).\n\n\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Text;\nusing System.Text.RegularExpressions;\n\nnamespace MadLibs_RosettaCode\n{\n\tclass Program\n\t{\n\t\tstatic void Main(string[] args)\n\t\t{\n\t\t\tstring madLibs = \n@\"Write a program to create a Mad Libs like story.\nThe program should read an arbitrary multiline story from input.\nThe story will be terminated with a blank line.\nThen, find each replacement to be made within the story, \nask the user for a word to replace it with, and make all the replacements.\nStop when there are none left and print the final story.\nThe input should be an arbitrary story in the form:\n<name> went for a walk in the park. <he or she>\nfound a <noun>. <name> decided to take it home.\nGiven this example, it should then ask for a name, \na he or she and a noun (<name> gets replaced both times with the same value).\";\n\n\t\t\tStringBuilder sb = new StringBuilder();\n\t\t\tRegex pattern = new Regex(@\"\\<(.*?)\\>\");\n\t\t\tstring storyLine;\n\t\t\tstring replacement;\n\n\t\t\tConsole.WriteLine(madLibs + Environment.NewLine + Environment.NewLine);\n\t\t\tConsole.WriteLine(\"Enter a story: \");\n\n\t\t\t// Continue to get input while empty line hasn't been entered.\n\t\t\tdo\n\t\t\t{\n\t\t\t\tstoryLine = Console.ReadLine();\n\t\t\t\tsb.Append(storyLine + Environment.NewLine);\n\t\t\t} while (!string.IsNullOrEmpty(storyLine) && !string.IsNullOrWhiteSpace(storyLine));\n\n\t\t\t// Retrieve only the unique regex matches from the user entered story.\n\t\t\tMatch nameMatch = pattern.Matches(sb.ToString()).OfType<Match>().Where(x => x.Value.Equals(\"<name>\")).Select(x => x.Value).Distinct() as Match;\n\t\t\tif(nameMatch != null)\n\t\t\t{\n\t\t\t\tdo\n\t\t\t\t{\n\t\t\t\t\tConsole.WriteLine(\"Enter value for: \" + nameMatch.Value);\n\t\t\t\t\treplacement = Console.ReadLine();\n\t\t\t\t} while (string.IsNullOrEmpty(replacement) || string.IsNullOrWhiteSpace(replacement));\n\t\t\t\tsb.Replace(nameMatch.Value, replacement);\n\t\t\t}\n\n\t\t\tforeach (Match match in pattern.Matches(sb.ToString()))\n\t\t\t{\n\t\t\t\treplacement = string.Empty;\n\t\t\t\t// Guarantee we get a non-whitespace value for the replacement\n\t\t\t\tdo\n\t\t\t\t{\n\t\t\t\t\tConsole.WriteLine(\"Enter value for: \" + match.Value);\n\t\t\t\t\treplacement = Console.ReadLine();\n\t\t\t\t} while (string.IsNullOrEmpty(replacement) || string.IsNullOrWhiteSpace(replacement));\n\n\t\t\t\tint location = sb.ToString().IndexOf(match.Value);\n\t\t\t\tsb.Remove(location, match.Value.Length).Insert(location, replacement);\n\t\t\t}\n\n\t\t\tConsole.WriteLine(Environment.NewLine + Environment.NewLine + \"--[ Here's your story! ]--\");\n\t\t\tConsole.WriteLine(sb.ToString());\n\t\t}\n\t}\n}\n"}
{"title": "Magic 8-ball", "language": "C#", "task": "Create Magic 8-Ball. \n\n\nSee details at:   Magic 8-Ball.\n\n\n\n", "solution": "using System;\n\nnamespace newProg\n{\n\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            string[] answers =\n            {\n                \"It is certain.\",\n                \"It is decidedly so.\",\n                \"Without a doubt.\",\n                \"Yes \u2013 definitely.\",\n                \"You may rely on it.\",\n                \"As I see it, yes.\",\n                \"Most likely.\",\n                \"Outlook good.\",\n                \"Yes.\",\n                \"Signs point to yes.\",\n                \"Reply hazy, try again.\",\n                \"Ask again later\",\n                \"Better not tell you now.\",\n                \"Cannot predict now.\",\n                \"Concentrate and ask again.\",\n                \"Don't count on it.\",\n                \"My reply is no.\",\n                \"My sources say no.\",\n                \"Outlook not so good.\",\n                \"Very doubtful.\"\n            };\n\n            while (true)\n            {\n                Random rnd = new Random();\n                int result = rnd.Next(0, 19);\n\n                Console.WriteLine(\"Magic 8 Ball! Ask question and hit a key for the answer!\");\n\n                string inp = Console.ReadLine();\n                \n                Console.WriteLine(answers[result]);\n\n            }\n        }\n    }\n}\n\n\n"}
{"title": "Magic squares of doubly even order", "language": "C sharp|C# from Java", "task": "A magic square is an   '''NxN'''  square matrix whose numbers consist of consecutive numbers arranged so that the sum of each row and column,   ''and''   both diagonals are equal to the same sum   (which is called the ''magic number'' or ''magic constant'').  \n\nA magic square of doubly even order has a size that is a multiple of four   (e.g.     '''4''', '''8''', '''12'''). \n\nThis means that the subsquares also have an even size, which plays a role in the construction.\n\n \n{| class=\"wikitable\" style=\"float:right;border: 2px solid black; background:lightblue; color:black; margin-left:auto;margin-right:auto;text-align:center;width:22em;height:15em;table-layout:fixed;font-size:100%\"\n|-\n|'''1'''||'''2'''||'''62'''||'''61'''||'''60'''||'''59'''||'''7'''||'''8'''\n|-\n|'''9'''||'''10'''||'''54'''||'''53'''||'''52'''||'''51'''||'''15'''||'''16'''\n|-\n|'''48'''||'''47'''||'''19'''||'''20'''||'''21'''||'''22'''||'''42'''||'''41'''\n|-\n|'''40'''||'''39'''||'''27'''||'''28'''||'''29'''||'''30'''||'''34'''||'''33'''\n|-\n|'''32'''||'''31'''||'''35'''||'''36'''||'''37'''||'''38'''||'''26'''||'''25'''\n|-\n|'''24'''||'''23'''||'''43'''||'''44'''||'''45'''||'''46'''||'''18'''||'''17'''\n|-\n|'''49'''||'''50'''||'''14'''||'''13'''||'''12'''||'''11'''||'''55'''||'''56'''\n|-\n|'''57'''||'''58'''||'''6'''||'''5'''||'''4'''||'''3'''||'''63'''||'''64'''\n|}\n\n;Task\nCreate a magic square of    '''8 x 8'''.\n\n\n;Related tasks\n* [[Magic squares of odd order]]\n* [[Magic squares of singly even order]]\n\n\n;See also:\n* Doubly Even Magic Squares (1728.org)\n\n", "solution": "using System;\n\nnamespace MagicSquareDoublyEven\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            int n = 8;\n            var result = MagicSquareDoublyEven(n);\n            for (int i = 0; i < result.GetLength(0); i++)\n            {\n                for (int j = 0; j < result.GetLength(1); j++)\n                    Console.Write(\"{0,2} \", result[i, j]);\n                Console.WriteLine();\n            }\n            Console.WriteLine(\"\\nMagic constant: {0} \", (n * n + 1) * n / 2);\n            Console.ReadLine();\n        }\n\n        private static int[,] MagicSquareDoublyEven(int n)\n        {\n            if (n < 4 || n % 4 != 0)\n                throw new ArgumentException(\"base must be a positive \"\n                        + \"multiple of 4\");\n\n            // pattern of count-up vs count-down zones\n            int bits = 0b1001_0110_0110_1001;\n            int size = n * n;\n            int mult = n / 4;  // how many multiples of 4\n\n            int[,] result = new int[n, n];\n\n            for (int r = 0, i = 0; r < n; r++)\n            {\n                for (int c = 0; c < n; c++, i++)\n                {\n                    int bitPos = c / mult + (r / mult) * 4;\n                    result[r, c] = (bits & (1 << bitPos)) != 0 ? i + 1 : size - i;\n                }\n            }\n            return result;\n        }\n    }\n}"}
{"title": "Map range", "language": "C sharp", "task": "Given two ranges: \n:::*   [a_1,a_2]   and \n:::*   [b_1,b_2];  \n:::*   then a value   s   in range   [a_1,a_2]\n:::*   is linearly mapped to a value   t   in range   [b_1,b_2]\n   where: \n\n\n:::*   t = b_1 + {(s - a_1)(b_2 - b_1) \\over (a_2 - a_1)}\n\n\n;Task:\nWrite a function/subroutine/... that takes two ranges and a real number, and returns the mapping of the real number from the first to the second range. \n\nUse this function to map values from the range    [0, 10]    to the range    [-1, 0]. \n\n\n;Extra credit:\nShow additional idiomatic ways of performing the mapping, using tools available to the language.\n\n", "solution": "using System;\nusing System.Linq;\n\npublic class MapRange\n{\n    public static void Main() {\n        foreach (int i in Enumerable.Range(0, 11))\n            Console.WriteLine($\"{i} maps to {Map(0, 10, -1, 0, i)}\");\n    }\n    \n    static double Map(double a1, double a2, double b1, double b2, double s) => b1 + (s - a1) * (b2 - b1) / (a2 - a1);\n}"}
{"title": "Maximum triangle path sum", "language": "C sharp|C#", "task": "Starting from the top of a pyramid of numbers like this, you can walk down going one step on the right or on the left, until you reach the bottom row:\n\n                          55\n                        94 48\n                       95 30 96\n                     77 71 26 67\n\n\nOne of such walks is 55 - 94 - 30 - 26. \nYou can compute the total of the numbers you have seen in such walk, \nin this case it's 205.\n\nYour problem is to find the maximum total among all possible paths from the top to the bottom row of the triangle. In the little example above it's 321.\n\n\n;Task:\nFind the maximum total in the triangle below:\n\n                          55\n                        94 48\n                       95 30 96\n                     77 71 26 67\n                    97 13 76 38 45\n                  07 36 79 16 37 68\n                 48 07 09 18 70 26 06\n               18 72 79 46 59 79 29 90\n              20 76 87 11 32 07 07 49 18\n            27 83 58 35 71 11 25 57 29 85\n           14 64 36 96 27 11 58 56 92 18 55\n         02 90 03 60 48 49 41 46 33 36 47 23\n        92 50 48 02 36 59 42 79 72 20 82 77 42\n      56 78 38 80 39 75 02 71 66 66 01 03 55 72\n     44 25 67 84 71 67 11 61 40 57 58 89 40 56 36\n   85 32 25 85 57 48 84 35 47 62 17 01 01 99 89 52\n  06 71 28 75 94 48 37 10 23 51 06 48 53 18 74 98 15\n27 02 92 23 08 71 76 84 15 52 92 63 81 10 44 10 69 93\n\n\nSuch numbers can be included in the solution code, or read from a \"triangle.txt\" file.\n\nThis task is derived from the Euler Problem #18.\n\n", "solution": "using System;\n\nnamespace RosetaCode\n{\n\tclass MainClass\n\t{\n\t\tpublic static void Main (string[] args)\n\t\t{\n\t\t\tint[,] list = new int[18,19];\n\t\t\tstring input = @\"55\n\t                        94 48\n\t                       95 30 96\n\t                     77 71 26 67\n\t                    97 13 76 38 45\n\t                  07 36 79 16 37 68\n\t                 48 07 09 18 70 26 06\n\t               18 72 79 46 59 79 29 90\n\t              20 76 87 11 32 07 07 49 18\n\t            27 83 58 35 71 11 25 57 29 85\n\t           14 64 36 96 27 11 58 56 92 18 55\n\t         02 90 03 60 48 49 41 46 33 36 47 23\n\t        92 50 48 02 36 59 42 79 72 20 82 77 42\n\t      56 78 38 80 39 75 02 71 66 66 01 03 55 72\n\t     44 25 67 84 71 67 11 61 40 57 58 89 40 56 36\n\t   85 32 25 85 57 48 84 35 47 62 17 01 01 99 89 52\n\t  06 71 28 75 94 48 37 10 23 51 06 48 53 18 74 98 15\n\t27 02 92 23 08 71 76 84 15 52 92 63 81 10 44 10 69 93\";\n\t\t\tvar charArray = input.Split ('\\n');\n\n\t\t\tfor (int i=0; i < charArray.Length; i++) {\n\t\t\t\tvar numArr = charArray[i].Trim().Split(' ');\n\n\t\t\t\tfor (int j = 0; j<numArr.Length; j++)\n\t\t\t\t{\n\t\t\t\t\tint number = Convert.ToInt32 (numArr[j]);\n\t\t\t\t\tlist [i, j] = number;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor (int i = 16; i >= 0; i--) {\n\t\t\t\tfor (int j = 0; j < 18; j++) {\n\t\t\t\t\tlist[i,j] = Math.Max(list[i, j] + list[i+1, j], list[i,j] + list[i+1, j+1]);\n\t\t\t\t}\n\t\t\t}\n\t\t\tConsole.WriteLine (string.Format(\"Maximum total: {0}\", list [0, 0]));\n\t\t}\n\t}\n}\n\n"}
{"title": "McNuggets problem", "language": "C sharp|C#", "task": "From Wikipedia:\n The McNuggets version of the coin problem was introduced by Henri Picciotto,\n who included it in his algebra textbook co-authored with Anita Wah. Picciotto\n thought of the application in the 1980s while dining with his son at\n McDonald's, working the problem out on a napkin. A McNugget number is\n the total number of McDonald's Chicken McNuggets in any number of boxes.\n In the United Kingdom, the original boxes (prior to the introduction of\n the Happy Meal-sized nugget boxes) were of 6, 9, and 20 nuggets.\n\n;Task:\nCalculate (from 0 up to a limit of 100) the largest non-McNuggets\nnumber (a number ''n'' which cannot be expressed with ''6x + 9y + 20z = n''\nwhere ''x'', ''y'' and ''z'' are natural numbers).\n\n", "solution": "using System;\n\npublic class McNuggets\n{\n   public static void Main()\n   {\n      bool[] isMcNuggetNumber = new bool[101];\n      \n      for (int x = 0; x <= 100/6; x++)\n      {\n         for (int y = 0; y <= 100/9; y++)\n         {\n            for (int z = 0; z <= 100/20; z++)\n            {\n               int mcNuggetNumber = x*6 + y*9 + z*20;\n               if (mcNuggetNumber <= 100)\n               {\n                  isMcNuggetNumber[mcNuggetNumber] = true;\n               }\n            }\n         } \n      }\n\n      for (int mnnCheck = isMcNuggetNumber.Length-1; mnnCheck >= 0; mnnCheck--)\n      {\n         if (!isMcNuggetNumber[mnnCheck])\n         {\n            Console.WriteLine(\"Largest non-McNuggett Number less than 100: \" + mnnCheck.ToString());\n            break;\n         }\n      }\n   }\n}\n"}
{"title": "Metaprogramming", "language": "C sharp|C#", "task": "{{omit from|BBC BASIC}}\nName and briefly demonstrate any support your language has for metaprogramming. Your demonstration may take the form of cross-references to other tasks on Rosetta Code. When possible, provide links to relevant documentation. \n\nFor the purposes of this task, \"support for metaprogramming\" means any way the user can effectively modify the language's syntax that's built into the language (like Lisp macros) or that's conventionally used with the language (like the C preprocessor). Such facilities need not be very powerful: even user-defined infix operators count. On the other hand, in general, neither operator overloading nor eval count. The task author acknowledges that what qualifies as metaprogramming is largely a judgment call.\n\n", "solution": "Metaprogramming in C# can be achieved using the [https://msdn.microsoft.com/en-us/library/bb126445.aspx Text Template Transformation Toolkit]. It is a textual preprocessor embedded in Visual Studio (it can also be executed from the command-line, e.g. in build scripts). It is language-agnostic, and therefore can generate code for C#, Visual Basic or other languages. This also means that it has no features which help manipulating the underlying language: it is purely textual, and does '''not''' include a C# parser to transform existing C# files (so you will need to roll your own or use [https://roslyn.codeplex.com/ Roslyn]), and does '''not''' include utilities which would help with combining pieces of code.\n\n"}
{"title": "Mian-Chowla sequence", "language": "C#|CSharp from Go", "task": "The Mian-Chowla sequence is an integer sequence defined recursively.\n\n\nMian-Chowla is an infinite instance of a Sidon sequence, and belongs to the class known as B2 sequences.\n\n\nThe sequence starts with:\n\n::a1 = 1\n\nthen for n > 1, an is the smallest positive integer such that every pairwise sum\n\n::ai + aj \n\nis distinct, for all i and j less than or equal to n.\n\n;The Task:\n\n:* Find and display, here, on this page the first 30 terms of the Mian-Chowla sequence.\n:* Find and display, here, on this page the 91st through 100th terms of the Mian-Chowla sequence.\n\n\nDemonstrating working through the first few terms longhand:\n\n::a1 = 1\n\n::1 + 1 = 2\n\nSpeculatively try a2 = 2\n\n::1 + 1 = 2\n::1 + 2 = 3\n::2 + 2 = 4\n\nThere are no repeated sums so '''2''' is the next number in the sequence.\n\nSpeculatively try a3 = 3\n\n::1 + 1 = 2\n::1 + 2 = 3  \n::1 + 3 = 4\n::2 + 2 = 4\n::2 + 3 = 5\n::3 + 3 = 6\n\nSum of '''4''' is repeated so '''3''' is rejected.\n\nSpeculatively try a3 = 4\n\n::1 + 1 = 2\n::1 + 2 = 3\n::1 + 4 = 5\n::2 + 2 = 4\n::2 + 4 = 6\n::4 + 4 = 8\n\nThere are no repeated sums so '''4''' is the next number in the sequence.\n\nAnd so on...\n\n;See also:\n\n:* OEIS:A005282 Mian-Chowla sequence\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics;\nusing System.Linq;\n\nstatic class Program {\n    static int[] MianChowla(int n) {\n        int[] mc = new int[n - 1 + 1];\n        HashSet<int> sums = new HashSet<int>(), ts = new HashSet<int>();\n        int sum; mc[0] = 1; sums.Add(2);\n        for (int i = 1; i <= n - 1; i++) {\n            for (int j = mc[i - 1] + 1; ; j++) {\n                mc[i] = j;\n                for (int k = 0; k <= i; k++) {\n                    sum = mc[k] + j;\n                    if (sums.Contains(sum)) { ts.Clear(); break; }\n                    ts.Add(sum);\n                }\n                if (ts.Count > 0) { sums.UnionWith(ts); break; }\n            }\n        }\n        return mc;\n    }\n\n    static void Main(string[] args)\n    {\n        const int n = 100; Stopwatch sw = new Stopwatch();\n        string str = \" of the Mian-Chowla sequence are:\\n\";\n        sw.Start(); int[] mc = MianChowla(n); sw.Stop();\n        Console.Write(\"The first 30 terms{1}{2}{0}{0}Terms 91 to 100{1}{3}{0}{0}\" +\n            \"Computation time was {4}ms.{0}\", '\\n', str, string.Join(\" \", mc.Take(30)),\n            string.Join(\" \", mc.Skip(n - 10)), sw.ElapsedMilliseconds);\n    }\n}"}
{"title": "Minimal steps down to 1", "language": "C sharp 7", "task": "Given:\n* A starting, positive integer (greater than one), N.\n* A selection of possible integer perfect divisors, D.\n* And a selection of possible subtractors, S.\nThe goal is find the minimum number of steps  necessary to reduce N down to one.\n\nAt any step, the number may be:\n* Divided by any member of D if it is perfectly divided by D, (remainder zero).\n* OR have one of S subtracted from it, if N is greater than the member of S.\n\n\nThere may be many ways to reduce the initial N down to 1. Your program needs to:\n* Find the ''minimum'' number of ''steps'' to reach 1.\n* Show '''one''' way of getting fron N to 1 in those minimum steps.\n\n;Examples:\nNo divisors, D. a single subtractor of 1.\n:Obviousely N will take N-1 subtractions of 1 to reach 1\n\nSingle divisor of 2; single subtractor of 1:\n:N = 7 Takes 4 steps N -1=> 6, /2=> 3, -1=> 2, /2=> 1\n:N = 23 Takes 7 steps N -1=>22, /2=>11, -1=>10, /2=> 5, -1=> 4, /2=> 2, /2=> 1\n\nDivisors 2 and 3; subtractor 1:\n:N = 11 Takes 4 steps N -1=>10, -1=> 9, /3=> 3, /3=> 1\n\n;Task:\nUsing the possible divisors D, of 2 and 3; together with a possible subtractor S, of 1:\n\n:1. Show the number of steps and possible way of diminishing the numbers 1 to 10 down to 1.\n:2. Show a count of, and the numbers that: have the maximum minimal_steps_to_1, in the range 1 to 2,000.\n\nUsing the possible divisors D, of 2 and 3; together with a possible subtractor S, of 2:\n\n:3. Show the number of steps and possible way of diminishing the numbers 1 to 10 down to 1.\n:4. Show a count of, and the numbers that: have the maximum minimal_steps_to_1, in the range 1 to 2,000.\n\n\n;Optional stretch goal:\n:2a, and 4a: As in 2 and 4 above, but for N in the range 1 to 20_000\n\n\n;Reference:\n* Learn Dynamic Programming (Memoization & Tabulation) Video of similar task.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic static class MinimalSteps\n{\n    public static void Main() {\n        var (divisors, subtractors) = (new int[] { 2, 3 }, new [] { 1 });\n        var lookup = CreateLookup(2_000, divisors, subtractors);\n        Console.WriteLine($\"Divisors: [{divisors.Delimit()}], Subtractors: [{subtractors.Delimit()}]\");\n        PrintRange(lookup, 10);\n        PrintMaxMins(lookup);\n        lookup = CreateLookup(20_000, divisors, subtractors);\n        PrintMaxMins(lookup);\n        Console.WriteLine();\n\n        subtractors = new [] { 2 };\n        lookup = CreateLookup(2_000, divisors, subtractors);\n        Console.WriteLine($\"Divisors: [{divisors.Delimit()}], Subtractors: [{subtractors.Delimit()}]\");\n        PrintRange(lookup, 10);\n        PrintMaxMins(lookup);\n        lookup = CreateLookup(20_000, divisors, subtractors);\n        PrintMaxMins(lookup);\n    }\n\n    private static void PrintRange((char op, int param, int steps)[] lookup, int limit) {\n        for (int goal = 1; goal <= limit; goal++) {\n            var x = lookup[goal];\n            if (x.param == 0) {\n                Console.WriteLine($\"{goal} cannot be reached with these numbers.\");\n                continue;\n            }\n            Console.Write($\"{goal} takes {x.steps} {(x.steps == 1 ? \"step\" : \"steps\")}: \");\n            for (int n = goal; n > 1; ) {\n                Console.Write($\"{n},{x.op}{x.param}=> \");\n                n = x.op == '/' ? n / x.param : n - x.param;\n                x = lookup[n];\n            }\n            Console.WriteLine(\"1\");\n        }\n    }\n\n    private static void PrintMaxMins((char op, int param, int steps)[] lookup) {\n        var maxSteps = lookup.Max(x => x.steps);\n        var items = lookup.Select((x, i) => (i, x)).Where(t => t.x.steps == maxSteps).ToList();\n        Console.WriteLine(items.Count == 1\n            ? $\"There is one number below {lookup.Length-1} that requires {maxSteps} steps: {items[0].i}\"\n            : $\"There are {items.Count} numbers below {lookup.Length-1} that require {maxSteps} steps: {items.Select(t => t.i).Delimit()}\"\n        );\n    }\n\n    private static (char op, int param, int steps)[] CreateLookup(int goal, int[] divisors, int[] subtractors)\n    {\n        var lookup = new (char op, int param, int steps)[goal+1];\n        lookup[1] = ('/', 1, 0);\n        for (int n = 1; n < lookup.Length; n++) {\n            var ln = lookup[n];\n            if (ln.param == 0) continue;\n            for (int d = 0; d < divisors.Length; d++) {\n                int target = n * divisors[d];\n                if (target > goal) break;\n                if (lookup[target].steps == 0 || lookup[target].steps > ln.steps) lookup[target] = ('/', divisors[d], ln.steps + 1);\n            }\n            for (int s = 0; s < subtractors.Length; s++) {\n                int target = n + subtractors[s];\n                if (target > goal) break;\n                if (lookup[target].steps == 0 || lookup[target].steps > ln.steps) lookup[target] = ('-', subtractors[s], ln.steps + 1);\n            }\n        }\n        return lookup;\n    }\n\n    private static string Delimit<T>(this IEnumerable<T> source) => string.Join(\", \", source);\n}"}
{"title": "Minimum positive multiple in base 10 using only 0 and 1", "language": "C#|Csharp", "task": "Every positive integer has infinitely many base-10 multiples that only use the digits '''0''' and '''1'''. The goal of this task is to find and display the '''minimum''' multiple that has this property.\n\nThis is simple to do, but can be challenging to do efficiently.\n\nTo avoid repeating long, unwieldy phrases, the operation \"minimum positive multiple of a positive integer n in base 10 that only uses the digits 0 and 1\" will hereafter be referred to as \"'''B10'''\".\n\n;Task:\n\nWrite a routine to find the B10 of a given integer.  \n\nE.G. \n                   \n       '''n'''                  '''B10'''      '''n'''  x '''multiplier'''\n       1                    1    ( 1  x 1         )\n       2                   10    ( 2  x 5         )\n       7                 1001    ( 7  x 143       )\n       9            111111111    ( 9  x 12345679  )\n      10                   10    ( 10 x 1         )\n\nand so on.\n\nUse the routine to find and display here, on this page, the '''B10''' value for: \n\n    1 through 10, 95 through 105, 297, 576, 594, 891, 909, 999\n\nOptionally find '''B10''' for:\n\n    1998, 2079, 2251, 2277\n\nStretch goal; find '''B10''' for:\n\n    2439, 2997, 4878\n\nThere are many opportunities for optimizations, but avoid using magic numbers as much as possible. If you ''do'' use magic numbers, explain briefly why and what they do for your implementation.\n\n\n;See also:\n\n:* OEIS:A004290 Least positive multiple of n that when written in base 10 uses only 0's and 1's.\n:* How to find Minimum Positive Multiple in base 10 using only 0 and 1\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing static System.Console;\n \nclass Program {\n \n  static string B10(int n) {\n    int[] pow = new int[n + 1], val = new int[29];\n    for (int count = 0, ten = 1, x = 1; x <= n; x++) {\n      val[x] = ten;\n      for (int j = 0, t; j <= n; j++)\n        if (pow[j] != 0 && pow[j] != x && pow[t = (j + ten) % n] == 0)\n          pow[t] = x;\n      if (pow[ten] == 0) pow[ten] = x;\n      ten = (10 * ten) % n;\n      if (pow[0] != 0) {\n        x = n;\n        string s = \"\"; \n        while (x != 0) {\n          int p = pow[x % n];\n          if (count > p) s += new string('0', count - p);\n          count = p - 1;\n          s += \"1\";\n          x = (n + x - val[p]) % n;\n        }\n        if (count > 0) s += new string('0', count);\n        return s;\n      }\n    } \n    return \"1\";\n  }\n \n  static void Main(string[] args) {\n    string fmt = \"{0,4} * {1,24} = {2,-28}\\n\";\n    int[] m = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\n      95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,\n      297, 576, 594, 891, 909, 999, 1998, 2079, 2251, 2277, 2439, 2997, 4878 };\n    string[] r = new string[m.Length]; \n    WriteLine(fmt + new string('-', 62), \"n\", \"multiplier\", \"B10\");\n    var sw = System.Diagnostics.Stopwatch.StartNew();\n    for (int i = 0; i < m.Length; i++) r[i] = B10(m[i]);\n    sw.Stop();\n    for (int i = 0; i < m.Length; i++) Write(fmt, m[i], decimal.Parse(r[i]) / m[i], r[i]);\n    Write(\"\\nTook {0}ms\", sw.Elapsed.TotalMilliseconds);\n  }\n}"}
{"title": "Modular arithmetic", "language": "C sharp|C# from Java", "task": "equivalence relation called ''congruence''.  \n\nFor any positive integer p called the ''congruence modulus'', \ntwo numbers a and b are said to be ''congruent modulo p'' whenever there exists an integer k such that:\n:a = b + k\\,p\n\nThe corresponding set of multiplicative inverse for this task.\n\nAddition and multiplication on this ring have the same algebraic structure as in usual arithmetic, so that a function such as a polynomial expression could receive a ring element as argument and give a consistent result.\n\nThe purpose of this task is to show, if your programming language allows it, \nhow to redefine operators so that they can be used transparently on modular integers.  \nYou can do it either by using a dedicated library, or by implementing your own class.\n\nYou will use the following function for demonstration:\n:f(x) = x^{100} + x + 1\nYou will use 13 as the congruence modulus and you will compute f(10).\n\nIt is important that the function f is agnostic about whether or not its argument is modular; it should behave the same way with normal and modular integers.  \nIn other words, the function is an algebraic expression that could be used with any ring, not just integers.\n\n", "solution": "using System;\n\nnamespace ModularArithmetic {\n    interface IAddition<T> {\n        T Add(T rhs);\n    }\n    interface IMultiplication<T> {\n        T Multiply(T rhs);\n    }\n    interface IPower<T> {\n        T Power(int pow);\n    }\n    interface IOne<T> {\n        T One();\n    }\n\n    class ModInt : IAddition<ModInt>, IMultiplication<ModInt>, IPower<ModInt>, IOne<ModInt> {\n        private int modulo;\n\n        public ModInt(int value, int modulo) {\n            Value = value;\n            this.modulo = modulo;\n        }\n\n        public int Value { get; }\n\n        public ModInt One() {\n            return new ModInt(1, modulo);\n        }\n\n        public ModInt Add(ModInt rhs) {\n            return this + rhs;\n        }\n\n        public ModInt Multiply(ModInt rhs) {\n            return this * rhs;\n        }\n\n        public ModInt Power(int pow) {\n            return Pow(this, pow);\n        }\n\n        public override string ToString() {\n            return string.Format(\"ModInt({0}, {1})\", Value, modulo);\n        }\n\n        public static ModInt operator +(ModInt lhs, ModInt rhs) {\n            if (lhs.modulo != rhs.modulo) {\n                throw new ArgumentException(\"Cannot add rings with different modulus\");\n            }\n            return new ModInt((lhs.Value + rhs.Value) % lhs.modulo, lhs.modulo);\n        }\n\n        public static ModInt operator *(ModInt lhs, ModInt rhs) {\n            if (lhs.modulo != rhs.modulo) {\n                throw new ArgumentException(\"Cannot add rings with different modulus\");\n            }\n            return new ModInt((lhs.Value * rhs.Value) % lhs.modulo, lhs.modulo);\n        }\n\n        public static ModInt Pow(ModInt self, int p) {\n            if (p < 0) {\n                throw new ArgumentException(\"p must be zero or greater\");\n            }\n\n            int pp = p;\n            ModInt pwr = self.One();\n            while (pp-- > 0) {\n                pwr *= self;\n            }\n            return pwr;\n        }\n    }\n\n    class Program {\n        static T F<T>(T x) where T : IAddition<T>, IMultiplication<T>, IPower<T>, IOne<T> {\n            return x.Power(100).Add(x).Add(x.One());\n        }\n\n        static void Main(string[] args) {\n            ModInt x = new ModInt(10, 13);\n            ModInt y = F(x);\n            Console.WriteLine(\"x ^ 100 + x + 1 for x = {0} is {1}\", x, y);\n        }\n    }\n}"}
{"title": "Modular exponentiation", "language": "C sharp", "task": "Find the last   '''40'''   decimal digits of   a^b,   where\n\n::*   a = 2988348162058574136915891421498819466320163312926952423791023078876139\n::*   b = 2351399303373464486466122544523690094744975233415544072992656881240319\n\n\nA computer is too slow to find the entire value of   a^b. \n\nInstead, the program must use a fast algorithm for modular exponentiation:   a^b \\mod m.\n\nThe algorithm must work for any integers   a, b, m,     where   b \\ge 0   and   m > 0.\n\n", "solution": "using System;\nusing System.Numerics;\n\nclass Program\n{\n    static void Main() {\n        var a = BigInteger.Parse(\"2988348162058574136915891421498819466320163312926952423791023078876139\");\n        var b = BigInteger.Parse(\"2351399303373464486466122544523690094744975233415544072992656881240319\");\n        var m = BigInteger.Pow(10, 40);\n        Console.WriteLine(BigInteger.ModPow(a, b, m));\n    }\n}"}
{"title": "Modular inverse", "language": "C sharp", "task": "From Wikipedia:\n\nIn modulo    ''m''    is an integer    ''x''    such that\n\n::a\\,x \\equiv 1 \\pmod{m}.\n\nOr in other words, such that:\n\n::\\exists k \\in\\Z,\\qquad a\\, x = 1 + k\\,m\n\nIt can be shown that such an inverse exists   if and only if    ''a''    and    ''m''    are coprime,   but we will ignore this for this task.\n\n\n;Task:\nEither by implementing the algorithm, by using a dedicated library or by using a built-in function in \nyour language,   compute the modular inverse of   42 modulo 2017.\n\n", "solution": "public class Program\n{\n    static void Main()\n    {\n        System.Console.WriteLine(42.ModInverse(2017));\n    }\n}\n\npublic static class IntExtensions\n{\n    public static int ModInverse(this int a, int m)\n    {\n        if (m == 1) return 0;\n        int m0 = m;\n        (int x, int y) = (1, 0);\n\n        while (a > 1) {\n            int q = a / m;\n            (a, m) = (m, a % m);\n            (x, y) = (y, x - q * y);\n        }\n        return x < 0 ? x + m0 : x;\n    }\n}"}
{"title": "Monads/Maybe monad", "language": "C sharp|C#", "task": "Demonstrate in your programming language the following:\n\n#Construct a Maybe Monad by writing the 'bind' function and the 'unit' (sometimes known as 'return') function for that Monad (or just use what the language already has implemented)\n#Make two functions, each which take a number and return a monadic number, e.g. Int -> Maybe Int and Int -> Maybe String\n#Compose the two functions with bind\n\n\nA Monad is a single type which encapsulates several other types, eliminating boilerplate code. In practice it acts like a dynamically typed computational sequence, though in many cases the type issues can be resolved at compile time.\n\nA Maybe Monad is a monad which specifically encapsulates the type of an undefined value.\n\n", "solution": "using System;\n\nnamespace RosettaMaybe\n{\n    // courtesy of https://www.dotnetcurry.com/patterns-practices/1510/maybe-monad-csharp\n    public abstract class Maybe<T>\n    {\n        public sealed class Some : Maybe<T>\n        {\n            public Some(T value) => Value = value;\n            public T Value { get; }\n        }\n        public sealed class None : Maybe<T> { }\n    }\n\n    class Program\n    {\n        static Maybe<double> MonadicSquareRoot(double x)\n        {\n            if (x >= 0)\n            {\n                return new Maybe<double>.Some(Math.Sqrt(x));\n            }\n            else\n            {\n                return new Maybe<double>.None();\n            }\n        }\n        static void Main(string[] args)\n        {\n            foreach (double x in new double[] { 4.0D, 8.0D, -15.0D, 16.23D, -42 })\n            {\n                Maybe<double> maybe = MonadicSquareRoot(x);\n                if (maybe is Maybe<double>.Some some)\n                {\n                    Console.WriteLine($\"The square root of {x} is \" + some.Value);\n                }\n                else\n                {\n                    Console.WriteLine($\"Square root of {x} is undefined.\");\n                }\n            }\n        }\n    }\n}"}
{"title": "Move-to-front algorithm", "language": "C sharp|C#", "task": "Given a symbol table of a ''zero-indexed'' array of all possible input symbols\nthis algorithm reversibly transforms a sequence\nof input symbols into an array of output numbers (indices).\n\nThe transform in many cases acts to give frequently repeated input symbols\nlower indices which is  useful in some compression algorithms.\n\n\n;Encoding algorithm:\n\n    for each symbol of the input sequence:\n        output the index of the symbol in the symbol table\n        move that symbol to the front of the symbol table\n\n\n\n;Decoding algorithm:\n\n    # Using the same starting symbol table\n    for each index of the input sequence:\n        output the symbol at that index of the symbol table\n        move that symbol to the front of the symbol table\n\n\n\n;Example:\nEncoding the string of character symbols 'broood' using a symbol table of the lowercase characters   '''a'''-to-'''z'''\n\n:::::{| class=\"wikitable\" border=\"1\"\n|-\n! Input\n! Output\n! SymbolTable\n|-\n| '''b'''roood\n| 1\n| 'abcdefghijklmnopqrstuvwxyz'\n|-\n| b'''r'''oood\n| 1 17\n| 'bacdefghijklmnopqrstuvwxyz'\n|-\n| br'''o'''ood\n| 1 17 15\n| 'rbacdefghijklmnopqstuvwxyz'\n|-\n| bro'''o'''od\n| 1 17 15 0\n| 'orbacdefghijklmnpqstuvwxyz'\n|-\n| broo'''o'''d\n| 1 17 15 0 0\n| 'orbacdefghijklmnpqstuvwxyz'\n|-\n| brooo'''d'''\n| 1 17 15 0 0 5\n| 'orbacdefghijklmnpqstuvwxyz'\n|}\n\n\nDecoding the indices back to the original symbol order:\n:::::{| class=\"wikitable\" border=\"1\"\n|-\n! Input\n! Output\n! SymbolTable\n|-\n|  '''1''' 17 15 0 0 5\n| b\n| 'abcdefghijklmnopqrstuvwxyz'\n|-\n| 1 '''17''' 15 0 0 5\n| br\n| 'bacdefghijklmnopqrstuvwxyz'\n|-\n| 1 17 '''15''' 0 0 5\n| bro\n| 'rbacdefghijklmnopqstuvwxyz'\n|-\n| 1 17 15 '''0''' 0 5\n| broo\n| 'orbacdefghijklmnpqstuvwxyz'\n|-\n| 1 17 15 0 '''0''' 5\n| brooo\n| 'orbacdefghijklmnpqstuvwxyz'\n|-\n| 1 17 15 0 0 '''5''' \n| broood\n| 'orbacdefghijklmnpqstuvwxyz'\n|}\n\n\n;Task:\n:*   Encode and decode the following three strings of characters using the symbol table of the lowercase characters   '''a'''-to-'''z'''   as above. \n:*   Show the strings and their encoding here.\n:*   Add a check to ensure that the decoded string is the same as the original.\n\n\nThe strings are: \n\n    broood       \n bananaaa     \n hiphophiphop \n(Note the misspellings in the above strings.)\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Text;\n\nnamespace MoveToFront\n{\n    class Program\n    {\n        private static char[] symbolTable;\n        private static void setSymbolTable()\n        {\n            symbolTable = \"abcdefghijklmnopqrstuvwxyz\".ToCharArray();\n        }\n\n        private static void moveToFront(int charIndex)\n        {\n            char toFront = symbolTable[charIndex];\n            for (int j = charIndex; j > 0; j--)\n            {\n                symbolTable[j] = symbolTable[j - 1];\n            }\n            symbolTable[0] = toFront;\n        }\n\n        public static int[] Encode(string input)\n        {\n            setSymbolTable();\n            var output = new List<int>();\n            foreach (char c in input)\n            {\n                for (int i = 0; i < 26; i++)\n                {\n                    if (symbolTable[i] == c)\n                    {\n                        output.Add(i);\n                        moveToFront(i);\n                        break;\n                    }\n                }\n            }         \n            return output.ToArray();\n        }\n\n        public static string Decode(int[] input)\n        {\n            setSymbolTable();\n            var output = new StringBuilder(input.Length);\n            foreach (int n in input)\n            {\n                output.Append(symbolTable[n]);\n                moveToFront(n);\n            }\n            return output.ToString();\n        }\n\n        static void Main(string[] args)\n        {\n            string[] testInputs = new string[] { \"broood\", \"bananaaa\", \"hiphophiphop\" };\n            int[] encoding;\n            foreach (string s in testInputs) \n            {\n                Console.WriteLine($\"Encoding for '{s}':\");\n                encoding = Encode(s);\n                foreach (int i in encoding)\n                {\n                    Console.Write($\"{i} \");\n                }\n                Console.WriteLine($\"\\nDecoding for '{s}':\");\n                Console.WriteLine($\"{Decode(encoding)}\\n\");\n            }\n        }\n    }\n}\n"}
{"title": "Multi-dimensional array", "language": "C sharp 3", "task": "For the purposes of this task, the actual memory layout or access method of this data structure is not mandated. \n\nIt is enough to:\n# State the number and extent of each index to the array.\n# Provide specific, ordered, integer indices for all dimensions of the array together with a new value to update the indexed value.\n# Provide specific, ordered, numeric indices for all dimensions of the array to obtain the arrays value at that indexed position.\n\n\n;Task:\n* State if the language supports multi-dimensional arrays in its syntax and usual implementation.\n* State whether the language uses row-major or column major order for multi-dimensional array storage, or any other relevant kind of storage.\n* Show how to create a four dimensional array in your language and set, access, set to another value; and access the new value of an integer-indexed item of the array. The idiomatic method for the language is preferred.\n:* The array should allow a range of five, four, three and two (or two three four five if convenient), in each of the indices, in order. (For example, ''if'' indexing starts at zero for the first index then a range of 0..4 inclusive would suffice).\n* State if memory allocation is optimised for the array - especially if contiguous memory is likely to be allocated.\n* If the language has exceptional native multi-dimensional array support such as optional bounds checking, reshaping, or being able to state both the lower and upper bounds of index ranges, then this is the task to mention them.\n\n\nShow all output here, (but you may judiciously use ellipses to shorten repetitive output text).\n\n", "solution": "var array = (int[,,,])Array.CreateInstance(typeof(int), new [] { 5, 4, 3, 2 }, new [] { 10, 10, 10, 10 });\nint n = 1;\n//Note: GetUpperBound is inclusive\nfor (int a = array.GetLowerBound(0); a <= array.GetUpperBound(0); a++)\nfor (int b = array.GetLowerBound(1); b <= array.GetUpperBound(1); b++)\nfor (int c = array.GetLowerBound(2); c <= array.GetUpperBound(2); c++)\nfor (int d = array.GetLowerBound(3); d <= array.GetUpperBound(3); d++)\n    array[a, b, c, d] = n++;\n\n//To set the first value, we must now use the lower bounds:\narray[10, 10, 10, 10] = 999;\n//As with all arrays, Length gives the TOTAL length.\nConsole.WriteLine(\"Length: \" + array.Length);\nConsole.WriteLine(\"First 30 elements:\");\n//The multidimensional array does not implement the generic IEnumerable<int>\n//so we need to cast the elements.\nConsole.WriteLine(string.Join(\" \",  array.Cast<int>().Take(30)) + \" ...\");"}
{"title": "Multifactorial", "language": "C sharp", "task": "The factorial of a number, written as n!, is defined as n! = n(n-1)(n-2)...(2)(1).\n\nMultifactorials generalize factorials as follows:\n: n! = n(n-1)(n-2)...(2)(1)\n: n!! = n(n-2)(n-4)...\n: n!! ! = n(n-3)(n-6)...\n: n!! !! = n(n-4)(n-8)...\n: n!! !! ! = n(n-5)(n-10)...\n\nIn all cases, the terms in the products are positive integers.\n\nIf we define the degree of the multifactorial as the difference in successive terms that are multiplied together for a multifactorial (the number of exclamation marks), then the task is twofold: \n# Write a function that given n and the degree, calculates the multifactorial.\n# Use the function to generate and display here a table of the first ten members (1 to 10) of the first five degrees of multifactorial.\n\n\n'''Note:''' The wikipedia entry on multifactorials gives a different formula. This task uses the Wolfram mathworld definition.\n\n", "solution": "namespace RosettaCode.Multifactorial\n{\n    using System;\n    using System.Linq;\n\n    internal static class Program\n    {\n        private static void Main()\n        {\n            Console.WriteLine(string.Join(Environment.NewLine,\n                                          Enumerable.Range(1, 5)\n                                                    .Select(\n                                                        degree =>\n                                                        string.Join(\" \",\n                                                                    Enumerable.Range(1, 10)\n                                                                              .Select(\n                                                                                  number =>\n                                                                                  Multifactorial(number, degree))))));\n        }\n\n        private static int Multifactorial(int number, int degree)\n        {\n            if (degree < 1)\n            {\n                throw new ArgumentOutOfRangeException(\"degree\");\n            }\n\n            var count = 1 + (number - 1) / degree;\n            if (count < 1)\n            {\n                throw new ArgumentOutOfRangeException(\"number\");\n            }\n\n            return Enumerable.Range(0, count)\n                             .Aggregate(1, (accumulator, index) => accumulator * (number - degree * index));\n        }\n    }\n}"}
{"title": "Multiple distinct objects", "language": "C sharp|C#", "task": "Create a [[sequence]] (array, list, whatever) consisting of n distinct, initialized items of the same type. n should be determined at runtime.\n\nBy ''distinct'' we mean that if they are mutable, changes to one do not affect all others; if there is an appropriate equality operator they are considered unequal; etc. The code need not specify a particular kind of distinction, but do not use e.g. a numeric-range generator which does not generalize.\n\nBy ''initialized'' we mean that each item must be in a well-defined state appropriate for its type, rather than e.g. arbitrary previous memory contents in an array allocation. Do not show only an initialization technique which initializes only to \"zero\" values (e.g. calloc() or int a[n] = {}; in C), unless user-defined types can provide definitions of \"zero\" for that type.\n\nThis task was inspired by the common error of intending to do this, but instead creating a sequence of n references to the ''same'' mutable object; it might be informative to show the way to do that as well, both as a negative example and as how to do it when that's all that's actually necessary.\n\nThis task is most relevant to languages operating in the pass-references-by-value style (most object-oriented, garbage-collected, and/or 'dynamic' languages).\n\nSee also: [[Closures/Value capture]]\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\nList<Foo> foos = Enumerable.Range(1, n).Select(x => new Foo()).ToList();"}
{"title": "Multisplit", "language": "C sharp", "task": "It is often necessary to split a string into pieces \nbased on several different (potentially multi-character) separator strings, \nwhile still retaining the information about which separators were present in the input. \n\nThis is particularly useful when doing small parsing tasks. \nThe task is to write code to demonstrate this.\n\nThe function (or procedure or method, as appropriate) should \ntake an input string and an ordered collection of separators. \n\nThe order of the separators is significant: \nThe delimiter order represents priority in matching, with the first defined delimiter having the highest priority. \nIn cases where there would be an ambiguity as to \nwhich separator to use at a particular point \n(e.g., because one separator is a prefix of another) \nthe separator with the highest priority should be used. \nDelimiters can be reused and the output from the function should be an ordered sequence of substrings.\n\nTest your code using the input string \"a!===b=!=c\" and the separators \"==\", \"!=\" and \"=\".\n\nFor these inputs the string should be parsed as \"a\" (!=) \"\" (==) \"b\" (=) \"\" (!=) \"c\", where matched delimiters are shown in parentheses, and separated strings are quoted, so our resulting output is \"a\", empty string, \"b\", empty string, \"c\". \nNote that the quotation marks are shown for clarity and do not form part of the output.\n\n'''Extra Credit:''' provide information that indicates which separator was matched at each separation point and where in the input string that separator was matched.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Multisplit\n{\n    internal static class Program\n    {\n        private static void Main(string[] args)\n        {\n            foreach (var s in \"a!===b=!=c\".Multisplit(true, \"==\", \"!=\", \"=\")) // Split the string and return the separators.\n            {\n                Console.Write(s); // Write the returned substrings and separators to the console.\n            }\n            Console.WriteLine();\n        }\n\n        private static IEnumerable<string> Multisplit(this string s, bool returnSeparators = false,\n                                                      params string[] delimiters)\n        {\n            var currentString = new StringBuilder(); /* Initiate the StringBuilder. This will hold the current string to return\n                                                      * once we find a separator. */\n\n            int index = 0; // Initiate the index counter at 0. This tells us our current position in the string to read.\n\n            while (index < s.Length) // Loop through the string.\n            {\n                // This will get the highest priority separator found at the current index, or null if there are none.\n                string foundDelimiter =\n                    (from delimiter in delimiters\n                     where s.Length >= index + delimiter.Length &&\n                           s.Substring(index, delimiter.Length) == delimiter\n                     select delimiter).FirstOrDefault();\n\n                if (foundDelimiter != null)\n                {\n                    yield return currentString.ToString(); // Return the current string.\n                    if (returnSeparators) // Return the separator, if the user specified to do so.\n                        yield return\n                            string.Format(\"{{\\\"{0}\\\", ({1}, {2})}}\",\n                                          foundDelimiter,\n                                          index, index + foundDelimiter.Length);\n                    currentString.Clear(); // Clear the current string.\n                    index += foundDelimiter.Length; // Move the index past the current separator.\n                }\n                else\n                {\n                    currentString.Append(s[index++]); // Add the character at this index to the current string.\n                }\n            }\n\n            if (currentString.Length > 0)\n                yield return currentString.ToString(); // If we have anything left over, return it.\n        }\n    }\n}"}
{"title": "Munchausen numbers", "language": "C sharp|C#", "task": "A Munchausen number is a natural number ''n'' the sum of whose digits (in base 10), each raised to the power of itself, equals ''n''.\n\n('''Munchausen''' is also spelled: '''Munchhausen'''.) \n\nFor instance:    3435 = 33 + 44 + 33 + 55 \n\n\n;Task\nFind all Munchausen numbers between   '''1'''   and   '''5000'''.\n\n\n;Also see:\n:* The OEIS entry:  A046253\n:* The Wikipedia entry:  Perfect digit-to-digit invariant, redirected from ''Munchausen Number''\n\n", "solution": "Func<char, int> toInt = c => c-'0';\n\nforeach (var i in Enumerable.Range(1,5000)\n\t.Where(n => n == n.ToString()\n\t\t.Sum(x => Math.Pow(toInt(x), toInt(x)))))\n\tConsole.WriteLine(i);"}
{"title": "Munchausen numbers", "language": "C sharp|C# from Kotlin", "task": "A Munchausen number is a natural number ''n'' the sum of whose digits (in base 10), each raised to the power of itself, equals ''n''.\n\n('''Munchausen''' is also spelled: '''Munchhausen'''.) \n\nFor instance:    3435 = 33 + 44 + 33 + 55 \n\n\n;Task\nFind all Munchausen numbers between   '''1'''   and   '''5000'''.\n\n\n;Also see:\n:* The OEIS entry:  A046253\n:* The Wikipedia entry:  Perfect digit-to-digit invariant, redirected from ''Munchausen Number''\n\n", "solution": "using System;\n\nnamespace Munchhausen\n{\n    class Program\n    {\n        static readonly long[] cache = new long[10];\n\n        static void Main()\n        {\n            // Allow for 0 ^ 0 to be 0\n            for (int i = 1; i < 10; i++)\n            {\n                cache[i] = (long)Math.Pow(i, i);\n            }\n\n            for (long i = 0L; i <= 500_000_000L; i++)\n            {\n                if (IsMunchhausen(i))\n                {\n                    Console.WriteLine(i);\n                }\n            }\n            Console.ReadLine();\n        }\n\n        private static bool IsMunchhausen(long n)\n        {\n            long sum = 0, nn = n;\n            do\n            {\n                sum += cache[(int)(nn % 10)];\n                if (sum > n)\n                {\n                    return false;\n                }\n                nn /= 10;\n            } while (nn > 0);\n\n            return sum == n;\n        }\n    }\n}"}
{"title": "Munchausen numbers", "language": "C sharp|C# from Visual Basic .NET", "task": "A Munchausen number is a natural number ''n'' the sum of whose digits (in base 10), each raised to the power of itself, equals ''n''.\n\n('''Munchausen''' is also spelled: '''Munchhausen'''.) \n\nFor instance:    3435 = 33 + 44 + 33 + 55 \n\n\n;Task\nFind all Munchausen numbers between   '''1'''   and   '''5000'''.\n\n\n;Also see:\n:* The OEIS entry:  A046253\n:* The Wikipedia entry:  Perfect digit-to-digit invariant, redirected from ''Munchausen Number''\n\n", "solution": "using System;\n\nstatic class Program\n{\n    public static void Main()\n    {\n        long sum, ten1 = 0, ten2 = 10; byte [] num; int [] pow = new int[10];\n        int i, j, n, n1, n2, n3, n4, n5, n6, n7, n8, n9, s2, s3, s4, s5, s6, s7, s8;\n        for (i = 1; i <= 9; i++) { pow[i] = i; for (j = 2; j <= i; j++) pow[i] *= i; }\n        for (n = 1; n <= 11; n++) { for (n9 = 0; n9 <= n; n9++) { for (n8 = 0; n8 <= n - n9; n8++) {\n              for (n7 = 0; n7 <= n - (s8 = n9 + n8); n7++) { for (n6 = 0; n6 <= n - (s7 = s8 + n7); n6++) {\n                  for (n5 = 0; n5 <= n - (s6 = s7 + n6); n5++) { for (n4 = 0; n4 <= n - (s5 = s6 + n5); n4++) {\n                      for (n3 = 0; n3 <= n - (s4 = s5 + n4); n3++) { for (n2 = 0; n2 <= n - (s3 = s4 + n3); n2++) {\n                          for (n1 = 0; n1 <= n - (s2 = s3 + n2); n1++) {\n                            sum = n1 * pow[1] + n2 * pow[2] + n3 * pow[3] + n4 * pow[4] + \n                                  n5 * pow[5] + n6 * pow[6] + n7 * pow[7] + n8 * pow[8] + n9 * pow[9];\n                            if (sum < ten1 || sum >= ten2) continue;\n                            num = new byte[10]; foreach (char ch in sum.ToString()) num[Convert.ToByte(ch) - 48] += 1;\n                            if (n - (s2 + n1) == num[0] && n1 == num[1] && n2 == num[2]\n                              && n3 == num[3] && n4 == num[4] && n5 == num[5] && n6 == num[6]\n                              && n7 == num[7] && n8 == num[8] && n9 == num[9]) Console.WriteLine(sum);\n                          } } } } } } } } }\n          ten1 = ten2; ten2 *= 10;\n        }\n    }\n}"}
{"title": "N-queens problem", "language": "C sharp|C#", "task": "right\n\nSolve the eight queens puzzle. \n\n\nYou can extend the problem to solve the puzzle with a board of size   '''N'''x'''N'''.\n \nFor the number of solutions for small values of   '''N''',   see   OEIS: A000170.\n\n\n;Related tasks:\n* [[A* search algorithm]]\n* [[Solve a Hidato puzzle]]\n* [[Solve a Holy Knight's tour]]\n* [[Knight's tour]]\n* [[Peaceful chess queen armies]]\n* [[Solve a Hopido puzzle]]\n* [[Solve a Numbrix puzzle]]\n* [[Solve the no connection puzzle]]\n\n", "solution": "=== Roger Hui (1981) Algorithm ===\nFrom Hui, Roger, The N Queens Problem, APL Quote-Quad, Volume 11, Number 3, 1981-03:-\n\n\"In a solution, each possible row (column) index must appear exactly once: an index occurring more than once means that two queens are on the same row (column); and the absence of an index means that some other index must occur more than once. Hence, we can specify an arrangement as a permutation of \u2373n , which are the column indices, with the row indices understood to be \u2373n . With this, the number of possibilities is reduced from n!n\u00d7n to !n . It remains to eliminate arrangements having two queens on the same diagonal.\n\nIf two queens occupy the same diagonal, the line connecting them has slope 1 or \u00af1 . Conversely, if the line connecting two queens has slope 1 or \u00af1 , the two queens share a diagonal. Therefore, we seek to eliminate all permutations specifying a pair of queens where\n((change in y) \u00f7 (change in x)) \u220a 1 \u00af1 , or (|change in y) = (|change in x)\"\n"}
{"title": "N-queens problem", "language": "C sharp", "task": "right\n\nSolve the eight queens puzzle. \n\n\nYou can extend the problem to solve the puzzle with a board of size   '''N'''x'''N'''.\n \nFor the number of solutions for small values of   '''N''',   see   OEIS: A000170.\n\n\n;Related tasks:\n* [[A* search algorithm]]\n* [[Solve a Hidato puzzle]]\n* [[Solve a Holy Knight's tour]]\n* [[Knight's tour]]\n* [[Peaceful chess queen armies]]\n* [[Solve a Hopido puzzle]]\n* [[Solve a Numbrix puzzle]]\n* [[Solve the no connection puzzle]]\n\n", "solution": "using static System.Linq.Enumerable;\nusing static System.Console;\n\nnamespace N_Queens\n{\n    static class Program\n    {\n        static void Main(string[] args)\n        {\n            var n = 8;\n            var domain = Range(0, n).ToArray();\n\n            var amb = new Amb.Amb();\n            var queens = domain.Select(_ => amb.Choose(domain)).ToArray();\n            amb.Require(() => n == queens.Select(q=> q.Value).Distinct().Count());\n            amb.Require(() => n == domain.Select(i=> i + queens[i].Value).Distinct().Count());\n            amb.Require(() => n == domain.Select(i=> i - queens[i].Value).Distinct().Count());\n\n            if (amb.Disambiguate())\n            {\n                WriteLine(\"Position is row, value is column:-\");\n                WriteLine(string.Join(\" \", queens.AsEnumerable()));\n            }\n            else\n                WriteLine(\"amb is angry\");\n            Read();\n        }\n    }\n}"}
{"title": "Narcissist", "language": "C sharp", "task": "Quoting from the Esolangs wiki page:\n\n\nA '''narcissist''' (or '''Narcissus program''') is the decision-problem version of a [[quine]].\n\nA quine, when run, takes no input, but produces a copy of its own source code at its output. In contrast, a narcissist reads a string of symbols from its input, and produces no output except a \"1\" or \"accept\" if that string matches its own source code, or a \"0\" or \"reject\" if it does not.\n\n\nFor concreteness, in this task we shall assume that symbol = character. \n\nThe narcissist should be able to cope with any finite input, whatever its length. \n\nAny form of output is allowed, as long as the program always halts, and \"accept\", \"reject\" and \"not yet finished\" are distinguishable.\n\n", "solution": "using System;\nusing System.IO;\nusing System.Text;\nusing System.Text.RegularExpressions;\nnamespace Narcisisst\n{\n\tclass Program\n\t{\n\t\tpublic static void Main(string[] args)\n\t\t{\n\t\t\tconst string path = @\"E:\\Narcisisst\";\n\t\t\tstring[] thisFile = Directory.GetFiles(path , \"Program.cs\");\n\t\t\tStringBuilder sb = new StringBuilder();\n\t\t\t\n\t\t\t\tforeach (string readLine in File.ReadLines(thisFile[0]))\n\t\t\t\t{\n\t\t\t\t\tsb.Append(readLine);\n\t\t\t\t\tsb.Append(\"\\n\");\n\t\t\t\t}\n\t\t\t\t\n\t\t\tConsole.WriteLine(sb);\n\t\t\tstring input =String.Empty;\n\t\t\t       \tinput = Console.ReadLine();\n\t\t\t       \tConsole.WriteLine((Regex.IsMatch(sb.ToString(),input))?\"accept\":\"reject\");\n\t\t\t       \tConsole.ReadKey();\n\t\t\t }\n\t}\n}\n"}
{"title": "Narcissistic decimal number", "language": "C sharp|C#", "task": "A   Narcissistic decimal number   is a non-negative integer,   n,   that is equal to the sum of the   m-th   powers of each of the digits in the decimal representation of   n,   where   m   is the number of digits in the decimal representation of   n.\n\n\nNarcissistic (decimal) numbers are sometimes called   '''Armstrong'''   numbers, named after Michael F. Armstrong. \nThey are also known as   '''Plus Perfect'''   numbers.\n\n\n;An example:\n::::*   if   n   is   '''153''' \n::::*   then   m,   (the number of decimal digits)   is   '''3''' \n::::*   we have    13 + 53 + 33   =   1 + 125 + 27   =   '''153'''  \n::::*   and so   '''153'''   is a narcissistic decimal number\n\n\n;Task:\nGenerate and show here the first   '''25'''   narcissistic decimal numbers.\n\n\n\nNote:   0^1 = 0,   the first in the series. \n\n\n;See also:\n*   the  OEIS entry:     Armstrong (or Plus Perfect, or narcissistic) numbers.\n*   MathWorld entry:   Narcissistic Number.\n*   Wikipedia entry:     Narcissistic number.\n\n", "solution": "using System;\n\nnamespace Narcissistic\n{\n    class Narcissistic\n    {\n        public bool isNarcissistic(int z)\n        {\n            if (z < 0) return false;\n            string n = z.ToString();\n            int t = 0, l = n.Length;\n            foreach (char c in n)\n                t += Convert.ToInt32(Math.Pow(Convert.ToDouble(c - 48), l));\n\n            return t == z;\n        }\n    }\n\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            Narcissistic n = new Narcissistic();\n            int c = 0, x = 0;\n            while (c < 25)\n            {\n                if (n.isNarcissistic(x))\n                {\n                    if (c % 5 == 0) Console.WriteLine();\n                    Console.Write(\"{0,7} \", x);\n                    c++;\n                }\n                x++;\n            }\n            Console.WriteLine(\"\\n\\nPress any key to continue...\");\n            Console.ReadKey();\n        }\n    }\n}\n"}
{"title": "Narcissistic decimal number", "language": "C sharp|C# from FreeBASIC", "task": "A   Narcissistic decimal number   is a non-negative integer,   n,   that is equal to the sum of the   m-th   powers of each of the digits in the decimal representation of   n,   where   m   is the number of digits in the decimal representation of   n.\n\n\nNarcissistic (decimal) numbers are sometimes called   '''Armstrong'''   numbers, named after Michael F. Armstrong. \nThey are also known as   '''Plus Perfect'''   numbers.\n\n\n;An example:\n::::*   if   n   is   '''153''' \n::::*   then   m,   (the number of decimal digits)   is   '''3''' \n::::*   we have    13 + 53 + 33   =   1 + 125 + 27   =   '''153'''  \n::::*   and so   '''153'''   is a narcissistic decimal number\n\n\n;Task:\nGenerate and show here the first   '''25'''   narcissistic decimal numbers.\n\n\n\nNote:   0^1 = 0,   the first in the series. \n\n\n;See also:\n*   the  OEIS entry:     Armstrong (or Plus Perfect, or narcissistic) numbers.\n*   MathWorld entry:   Narcissistic Number.\n*   Wikipedia entry:     Narcissistic number.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing System.Numerics;\n\nstatic class Program\n{\n    public static void nar(int max, bool only1 = false)\n    {\n        int n, n1, n2, n3, n4, n5, n6, n7, n8, n9;\n        int[] d;                                       // digits tally\n        char [] bs;                                    // BigInteger String\n        List<BigInteger> res = new List<BigInteger>(); // per n digits results\n        BigInteger[,] p = new BigInteger[10, max + 1]; // powers array\n\n        // BigIntegers for intermediate results\n        BigInteger x2, x3, x4, x5, x6, x7, x8, x9;\n\n        for (n = only1 ? max : 1; n <= max; n++) // main loop\n        {\n            for (int i = 1; i <= 9; i++) // init powers array for this n\n            {\n                p[i, 1] = BigInteger.Pow(i, n);\n                for (int j = 2; j <= n; j++) p[i, j] = p[i, 1] * j;\n            }\n            for (n9 = n; n9 >= 0; n9--) // nested loops...\n            {\n                x9 = p[9, n9];\n                for (n8 = n - n9; n8 >= 0; n8--)\n                {\n                    x8 = x9 + p[8, n8];\n                    for (n7 = n - n9 - n8; n7 >= 0; n7--)\n                    {\n                        x7 = x8 + p[7, n7];\n                        for (n6 = n - n9 - n8 - n7; n6 >= 0; n6--)\n                        {\n                            x6 = x7 + p[6, n6];\n                            for (n5 = n - n9 - n8 - n7 - n6; n5 >= 0; n5--)\n                            {\n                                x5 = x6 + p[5, n5];\n                                for (n4 = n - n9 - n8 - n7 - n6 - n5; n4 >= 0; n4--)\n                                {\n                                    x4 = x5 + p[4, n4];\n                                    for (n3 = n - n9 - n8 - n7 - n6 - n5 - n4; n3 >= 0; n3--)\n                                    {\n                                        x3 = x4 + p[3, n3];\n                                        for (n2 = n - n9 - n8 - n7 - n6 - n5 - n4 - n3; n2 >= 0; n2--)\n                                        {\n                                            x2 = x3 + p[2, n2];\n                                            for (n1 = n - n9 - n8 - n7 - n6 - n5 - n4 - n3 - n2; n1 >= 0; n1--)\n                                            {\n                                                bs = (x2 + n1).ToString().ToCharArray();\n                                                switch (bs.Length.CompareTo(n))\n                                                { // Since all the for/next loops step down, when the digit count\n                                                  // becomes smaller than n, it's time to try the next n value.\n                                                    case -1: { goto Next_n; }\n                                                    case 0:\n                                                        {\n                                                            d = new int[10]; foreach (char c in bs) d[c - 48] += 1;\n                                                            if (n9 == d[9] && n8 == d[8] && n7 == d[7] && \n                                                                n6 == d[6] && n5 == d[5] && n4 == d[4] && \n                                                                n3 == d[3] && n2 == d[2] && n1 == d[1] && \n                                                                n - n9 - n8 - n7 - n6 - n5 - n4 - n3 - n2 - n1 == d[0])\n                                                                res.Add(BigInteger.Parse(new string(bs)));\n                                                            break;\n                                                        }\n                                                }\n                                            }\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\nNext_n:     if (only1) {\n                Console.Write(\"{0} \", n); lock (resu) resu.AddRange(res); return;\n            } else {\n                res.Sort(); Console.WriteLine(\"{2,3} {0,3}: {1}\", \n                Math.Ceiling((DateTime.Now - st).TotalSeconds), string.Join(\" \", res), n); res.Clear();\n            }\n        }\n    }\n\n    private static DateTime st = default(DateTime);\n    private static List<BigInteger> resu = new List<BigInteger>();\n    private static bool para = true; // parallel (default) or sequential calcualtion\n    private static int lim = 7;  // this is the number of digits to calcualate, not the nth entry.\n                                 // for up to the 25th item, use lim = 7 digits.\n                                 // for all 89 items, use lim = 39 digits.\n    public static void Main(string[] args)\n    {\n        if (args.Count() > 0)\n        {\n            int t = lim; int.TryParse(args[0], out t);\n            if (t < 1) t = 1;   // number of digits must be > 0\n            if (t > 61) t = 61; // no point when lim * math.pow(9, lim) < math.pow(10, lim - 1)\n            lim = t;\n            // default is parallel, will do sequential when any 2nd command line parameter is present.\n            para = !(args.Count() > 1);\n        }\n        st = DateTime.Now;\n        if (para)\n        {\n            Console.Write(\"Calculations in parallel... \"); // starts the bigger ones first\n            Parallel.ForEach(Enumerable.Range(1, lim).Reverse().ToArray(), n => { nar(n, true); } );\n            resu.Sort(); int[] g = Enumerable.Range(1, resu.Count).ToArray();\n            var both = g.Zip(resu, (a, b) => a.ToString() + \" \" + b.ToString());\n            Console.WriteLine(\"\\n{0}\", string.Join(\"\\n\", both));\n        }\n        else { Console.WriteLine(\"Sequential calculations:\"); nar(lim); }\n        Console.WriteLine(\"Total elasped: {0} seconds\", (DateTime.Now - st).TotalSeconds);\n        if (System.Diagnostics.Debugger.IsAttached) Console.ReadKey();\n    }\n}\n"}
{"title": "Negative base numbers", "language": "C sharp|C# from Java", "task": "Negative base numbers are an alternate way to encode numbers without the need for a minus sign. Various negative bases may be used including negadecimal (base -10), negabinary (-2) and negaternary (-3).Negabinary on Wolfram MathworldNegative base on Wikipedia\n\n\n;Task:\n\n*Encode the decimal number 10 as negabinary (expect 11110)\n*Encode the decimal number 146 as negaternary (expect 21102)\n*Encode the decimal number 15 as negadecimal (expect 195)\n*In each of the above cases, convert the encoded number back to decimal.\n\n\n;extra credit:\n\n* supply an integer, that when encoded to base   -62   (or something \"higher\"),   expresses the name of the language being used   (with correct capitalization).   If the computer language has non-alphanumeric characters,   try to encode them into the negatory numerals,   or use other characters instead.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace NegativeBaseNumbers {\n    class Program {\n        const string DIGITS = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\n\n        static string EncodeNegativeBase(long n, int b) {\n            if (b < -62 || b > -1) {\n                throw new ArgumentOutOfRangeException(\"b\");\n            }\n            if (n == 0) {\n                return \"0\";\n            }\n            StringBuilder output = new StringBuilder();\n            long nn = n;\n            while (nn != 0) {\n                int rem = (int)(nn % b);\n                nn /= b;\n                if (rem < 0) {\n                    nn++;\n                    rem -= b;\n                }\n                output.Append(DIGITS[rem]);\n            }\n            return new string(output.ToString().Reverse().ToArray());\n        }\n\n        static long DecodeNegativeBase(string ns, int b) {\n            if (b < -62 || b > -1) {\n                throw new ArgumentOutOfRangeException(\"b\");\n            }\n            if (ns == \"0\") {\n                return 0;\n            }\n            long total = 0;\n            long bb = 1;\n            for (int i = ns.Length - 1; i >= 0; i--) {\n                char c = ns[i];\n                total += DIGITS.IndexOf(c) * bb;\n                bb *= b;\n            }\n            return total;\n        }\n\n        static void Main(string[] args) {\n            List<Tuple<long, int>> nbl = new List<Tuple<long, int>>() {\n                new Tuple<long, int>(10,-2),\n                new Tuple<long, int>(146,-3),\n                new Tuple<long, int>(15,-10),\n                new Tuple<long, int>(-34025238427,-62),\n            };\n            foreach (var p in nbl) {\n                string ns = EncodeNegativeBase(p.Item1, p.Item2);\n                Console.WriteLine(\"{0,12} encoded in base {1,-3} = {2}\", p.Item1, p.Item2, ns);\n                long n = DecodeNegativeBase(ns, p.Item2);\n                Console.WriteLine(\"{0,12} decoded in base {1,-3} = {2}\", ns, p.Item2, n);\n                Console.WriteLine();\n            }\n        }\n    }\n}"}
{"title": "Nested function", "language": "C sharp|C#", "task": "In many languages, functions can be nested, resulting in outer functions and inner functions. The inner function can access variables from the outer function. In most languages, the inner function can also modify variables in the outer function.\n\n\n;Task: \nWrite a program consisting of two nested functions that prints the following text.\n\n 1. first\n 2. second\n 3. third\n\nThe outer function (called MakeList or equivalent) is responsible for creating the list as a whole and is given the separator \". \" as argument. It also defines a counter variable to keep track of the item number. This demonstrates how the inner function can influence the variables in the outer function.\n\nThe inner function (called MakeItem or equivalent) is responsible for creating a list item. It accesses the separator from the outer function and modifies the counter.\n\n\n;References:\n:* Nested function\n\n", "solution": "string MakeList(string separator)\n{\n    int counter = 1;\n\n    Func<string, string> makeItem = item => counter++ + separator + item + \"\\n\";\n\n    return makeItem(\"first\") + makeItem(\"second\") + makeItem(\"third\");\n}\n\nConsole.WriteLine(MakeList(\". \"));"}
{"title": "Nim game", "language": "C#", "task": "Nim is a simple game where the second player-if they know the trick-will always win.\n\n\nThe game has only 3 rules:\n::*   start with   '''12'''   tokens\n::*   each player takes    '''1,  2,  or  3'''   tokens in turn\n::*  the player who takes the last token wins.\n\n\nTo win every time,   the second player simply takes 4 minus the number the first player took.   So if the first player takes 1,   the second takes 3; if the first player takes 2,   the second should take 2; and if the first player takes 3,   the second player will take 1. \n\n;Task:\nDesign a simple Nim game where the human player goes first, and the computer always wins. The game should enforce the rules.\n\n", "solution": "using System;\n\nnamespace nimGame\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            Console.WriteLine(\"There are twelve tokens.\\n\" +\n                    \"You can take 1, 2, or 3 on your turn.\\n\" +\n                    \"Whoever takes the last token wins.\\n\");\n\n            int tokens = 12;\n\n            while (tokens > 0)\n            {\n                Console.WriteLine(\"There are \" + tokens + \" remaining.\");\n                Console.WriteLine(\"How many do you take?\");\n                int playertake = Convert.ToInt32(Console.ReadLine());\n\n                if (playertake < 1 | playertake > 3)\n                {\n                    Console.WriteLine(\"1, 2, or 3 only.\");\n                }\n                else\n                {\n                    tokens -= playertake;\n                    Console.WriteLine(\"I take \" + (4 - playertake) + \".\");\n                    tokens -= (4 - playertake);\n                }\n            }\n            Console.WriteLine(\"I win again.\");\n            Console.ReadLine();\n        }\n\n    }\n}\n"}
{"title": "Nonoblock", "language": "C sharp", "task": "Nonogram puzzle.\n\n\n;Given:\n* The number of cells in a row.\n* The size of each, (space separated), connected block of cells to fit in the row, in left-to right order.\n\n\n;Task: \n* show all possible positions. \n* show the number of positions of the blocks for the following cases within the row. \n* show all output on this page. \n* use a \"neat\" diagram of the block positions.\n\n\n;Enumerate the following configurations:\n#   '''5'''   cells   and   '''[2, 1]'''   blocks\n#   '''5'''   cells   and   '''[]'''   blocks   (no blocks)\n#   '''10'''   cells   and   '''[8]'''   blocks\n#   '''15'''   cells   and   '''[2, 3, 2, 3]'''   blocks\n#   '''5'''   cells   and   '''[2, 3]'''   blocks   (should give some indication of this not being possible)\n\n\n;Example:\nGiven a row of five cells and a block of two cells followed by a block of one cell - in that order, the example could be shown as:\n\n    |_|_|_|_|_| # 5 cells and [2, 1] blocks\n\nAnd would expand to the following 3 possible rows of block positions:\n\n    |A|A|_|B|_|\n    |A|A|_|_|B|\n    |_|A|A|_|B|\n\n\nNote how the sets of blocks are always separated by a space.\n\nNote also that it is not necessary for each block to have a separate letter. \nOutput approximating\n\nThis:\n                        |#|#|_|#|_|\n                        |#|#|_|_|#|\n                        |_|#|#|_|#|\n\nThis would also work:\n                        ##.#.\n                        ##..#\n                       .##.#\n\n\n;An algorithm:\n* Find the minimum space to the right that is needed to legally hold all but the leftmost block of cells (with a space between blocks remember).\n* The leftmost cell can legitimately be placed in all positions from the LHS up to a RH position that allows enough room for the rest of the blocks.\n* for each position of the LH block recursively compute the position of the rest of the blocks in the ''remaining'' space to the right of the current placement of the LH block.\n\n(This is the algorithm used in the [[Nonoblock#Python]] solution).    \n\n\n;Reference:\n* The blog post Nonogram puzzle solver (part 1) Inspired this task and donated its [[Nonoblock#Python]] solution.\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Text;\n\npublic static class Nonoblock\n{\n    public static void Main() {\n        Positions(5, 2,1);\n        Positions(5);\n        Positions(10, 8);\n        Positions(15, 2,3,2,3);\n        Positions(5, 2,3);\n    }\n\n    public static void Positions(int cells, params int[] blocks) {\n        if (cells < 0 || blocks == null || blocks.Any(b => b < 1)) throw new ArgumentOutOfRangeException();\n        Console.WriteLine($\"{cells} cells with [{string.Join(\", \", blocks)}]\");\n        if (blocks.Sum() + blocks.Length - 1 > cells) {\n            Console.WriteLine(\"No solution\");\n            return;\n        }\n        var spaces = new int[blocks.Length + 1];\n        int total = -1;\n        for (int i = 0; i < blocks.Length; i++) {\n            total += blocks[i] + 1;\n            spaces[i+1] = total;\n        }\n        spaces[spaces.Length - 1] = cells - 1;\n        var sb = new StringBuilder(string.Join(\".\", blocks.Select(b => new string('#', b))).PadRight(cells, '.'));\n        Iterate(sb, spaces, spaces.Length - 1, 0);\n        Console.WriteLine();\n    }\n\n    private static void Iterate(StringBuilder output, int[] spaces, int index, int offset) {\n        Console.WriteLine(output.ToString());\n        if (index <= 0) return;\n        int count = 0;\n        while (output[spaces[index] - offset] != '#') {\n            count++;\n            output.Remove(spaces[index], 1);\n            output.Insert(spaces[index-1], '.');\n            spaces[index-1]++;\n            Iterate(output, spaces, index - 1, 1);\n        }\n        if (offset == 0) return;\n        spaces[index-1] -= count;\n        output.Remove(spaces[index-1], count);\n        output.Insert(spaces[index] - count, \".\", count);\n    }\n\n}"}
{"title": "Nonogram solver", "language": "C sharp", "task": "nonogram is a puzzle that provides \nnumeric clues used to fill in a grid of cells, \nestablishing for each cell whether it is filled or not. \nThe puzzle solution is typically a picture of some kind.\n\nEach row and column of a rectangular grid is annotated with the lengths \nof its distinct runs of occupied cells. \nUsing only these lengths you should find one valid configuration \nof empty and occupied cells, or show a failure message.\n\n;Example\nProblem:                 Solution:\n\n. . . . . . . .  3       . # # # . . . .  3\n. . . . . . . .  2 1     # # . # . . . .  2 1\n. . . . . . . .  3 2     . # # # . . # #  3 2\n. . . . . . . .  2 2     . . # # . . # #  2 2\n. . . . . . . .  6       . . # # # # # #  6\n. . . . . . . .  1 5     # . # # # # # .  1 5\n. . . . . . . .  6       # # # # # # . .  6\n. . . . . . . .  1       . . . . # . . .  1\n. . . . . . . .  2       . . . # # . . .  2\n1 3 1 7 5 3 4 3          1 3 1 7 5 3 4 3\n2 1 5 1                  2 1 5 1   \nThe problem above could be represented by two lists of lists:\nx = [[3], [2,1], [3,2], [2,2], [6], [1,5], [6], [1], [2]]\ny = [[1,2], [3,1], [1,5], [7,1], [5], [3], [4], [3]]\nA more compact representation of the same problem uses strings, \nwhere the letters represent the numbers, A=1, B=2, etc:\nx = \"C BA CB BB F AE F A B\"\ny = \"AB CA AE GA E C D C\"\n\n;Task\nFor this task, try to solve the 4 problems below, read from a \"nonogram_problems.txt\" file that has this content \n(the blank lines are separators):\nC BA CB BB F AE F A B\nAB CA AE GA E C D C\n\nF CAC ACAC CN AAA AABB EBB EAA ECCC HCCC\nD D AE CD AE A DA BBB CC AAB BAA AAB DA AAB AAA BAB AAA CD BBA DA\n\nCA BDA ACC BD CCAC CBBAC BBBBB BAABAA ABAD AABB BBH BBBD ABBAAA CCEA AACAAB BCACC ACBH DCH ADBE ADBB DBE ECE DAA DB CC\nBC CAC CBAB BDD CDBDE BEBDF ADCDFA DCCFB DBCFC ABDBA BBF AAF BADB DBF AAAAD BDG CEF CBDB BBB FC\n\nE BCB BEA BH BEK AABAF ABAC BAA BFB OD JH BADCF Q Q R AN AAN EI H G\nE CB BAB AAA AAA AC BB ACC ACCA AGB AIA AJ AJ ACE AH BAF CAG DAG FAH FJ GJ ADK ABK BL CM\n\n'''Extra credit''': generate nonograms with unique solutions, of desired height and width.\n\nThis task is the problem n.98 of the \"99 Prolog Problems\" by Werner Hett (also thanks to Paul Singleton for the idea and the examples).\n\n; Related tasks\n* [[Nonoblock]].\n\n;See also\n* Arc Consistency Algorithm\n* http://www.haskell.org/haskellwiki/99_questions/Solutions/98 (Haskell)\n* http://twanvl.nl/blog/haskell/Nonograms (Haskell)\n* http://picolisp.com/5000/!wiki?99p98 (PicoLisp)\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing static System.Linq.Enumerable;\n\npublic static class NonogramSolver\n{\n    public static void Main2() {\n        foreach (var (x, y) in new [] {\n            (\"C BA CB BB F AE F A B\", \"AB CA AE GA E C D C\"),\n            (\"F CAC ACAC CN AAA AABB EBB EAA ECCC HCCC\",\n                \"D D AE CD AE A DA BBB CC AAB BAA AAB DA AAB AAA BAB AAA CD BBA DA\"),\n            (\"CA BDA ACC BD CCAC CBBAC BBBBB BAABAA ABAD AABB BBH BBBD ABBAAA CCEA AACAAB BCACC ACBH DCH ADBE ADBB DBE ECE DAA DB CC\",\n                \"BC CAC CBAB BDD CDBDE BEBDF ADCDFA DCCFB DBCFC ABDBA BBF AAF BADB DBF AAAAD BDG CEF CBDB BBB FC\"),\n            (\"E BCB BEA BH BEK AABAF ABAC BAA BFB OD JH BADCF Q Q R AN AAN EI H G\",\n                \"E CB BAB AAA AAA AC BB ACC ACCA AGB AIA AJ AJ ACE AH BAF CAG DAG FAH FJ GJ ADK ABK BL CM\")\n            })\n        {\n            Solve(x, y);\n            Console.WriteLine();\n        }\n    }\n\n    static void Solve(string rowLetters, string columnLetters) {\n        var r = rowLetters.Split(\" \").Select(row => row.Select(s => s - 'A' + 1).ToArray()).ToArray();\n        var c = columnLetters.Split(\" \").Select(column => column.Select(s => s - 'A' + 1).ToArray()).ToArray();\n        Solve(r, c);\n    }\n\n    static void Solve(int[][] rowRuns, int[][] columnRuns) {\n        int len = columnRuns.Length;\n        var rows = rowRuns.Select(row => Generate(len, row)).ToList();\n        var columns = columnRuns.Select(column => Generate(rowRuns.Length, column)).ToList();\n        Reduce(rows, columns);\n        foreach (var list in rows) {\n            if (list.Count != 1) Console.WriteLine(Repeat('?', len).Spaced());\n            else Console.WriteLine(list[0].ToString().PadLeft(len, '0').Replace('1', '#').Replace('0', '.').Reverse().Spaced());\n        }\n    }\n\n    static List<BitSet> Generate(int length, params int[] runs) {\n        var list = new List<BitSet>();\n        BitSet initial = BitSet.Empty;\n        int[] sums = new int[runs.Length];\n        sums[0] = 0;\n        for (int i = 1; i < runs.Length; i++) sums[i] = sums[i - 1] + runs[i - 1] + 1;\n        for (int r = 0; r < runs.Length; r++) initial = initial.AddRange(sums[r], runs[r]);\n        Generate(list, BitSet.Empty.Add(length), runs, sums, initial, 0, 0);\n        return list;\n    }\n\n    static void Generate(List<BitSet> result, BitSet max, int[] runs, int[] sums, BitSet current, int index, int shift) {\n        if (index == runs.Length) {\n            result.Add(current);\n            return;\n        }\n        while (current.Value < max.Value) {\n            Generate(result, max, runs, sums, current, index + 1, shift);\n            current = current.ShiftLeftAt(sums[index] + shift);\n            shift++;\n        }\n    }\n\n    static void Reduce(List<List<BitSet>> rows, List<List<BitSet>> columns) {\n        for (int count = 1; count > 0; ) {\n            foreach (var (rowIndex, row) in rows.WithIndex()) {\n                var allOn  = row.Aggregate((a, b) => a & b);\n                var allOff = row.Aggregate((a, b) => a | b);\n                foreach (var (columnIndex, column) in columns.WithIndex()) {\n                    count  = column.RemoveAll(c => allOn.Contains(columnIndex) && !c.Contains(rowIndex));\n                    count += column.RemoveAll(c => !allOff.Contains(columnIndex) && c.Contains(rowIndex));\n                }\n            }\n            foreach (var (columnIndex, column) in columns.WithIndex()) {\n                var allOn  = column.Aggregate((a, b) => a & b);\n                var allOff = column.Aggregate((a, b) => a | b);\n                foreach (var (rowIndex, row) in rows.WithIndex()) {\n                    count += row.RemoveAll(r => allOn.Contains(rowIndex) && !r.Contains(columnIndex));\n                    count += row.RemoveAll(r => !allOff.Contains(rowIndex) && r.Contains(columnIndex));\n                }\n            }\n        }\n    }\n\n    static IEnumerable<(int index, T element)> WithIndex<T>(this IEnumerable<T> source) {\n        int i = 0;\n        foreach (T element in source) {\n            yield return (i++, element);\n        }\n    }\n\n    static string Reverse(this string s) {\n        char[] array = s.ToCharArray();\n        Array.Reverse(array);\n        return new string(array);\n    }\n\n    static string Spaced(this IEnumerable<char> s) => string.Join(\" \", s);\n\n    struct BitSet //Unused functionality elided.\n    {\n        public static BitSet Empty => default;\n        private readonly int bits;\n        public int Value => bits;\n\n        private BitSet(int bits) => this.bits = bits;\n\n        public BitSet Add(int item) => new BitSet(bits | (1 << item));\n        public BitSet AddRange(int start, int count) => new BitSet(bits | (((1 << (start + count)) - 1) - ((1 << start) - 1)));\n        public bool Contains(int item) => (bits & (1 << item)) != 0;\n        public BitSet ShiftLeftAt(int index)  => new BitSet((bits >> index << (index + 1)) | (bits & ((1 << index) - 1)));\n        public override string ToString() => Convert.ToString(bits, 2);\n\n        public static BitSet operator &(BitSet a, BitSet b) => new BitSet(a.bits & b.bits);\n        public static BitSet operator |(BitSet a, BitSet b) => new BitSet(a.bits | b.bits);\n    }\n\n}"}
{"title": "Numbers which are not the sum of distinct squares", "language": "C#|CSharp", "task": "Integer squares are the set of integers multiplied by themselves: 1 x 1 = '''1''', 2 x 2 = '''4''', 3 x 3 = '''9''', etc. ( 1, 4, 9, 16 ... )\n\nMost positive integers can be generated as the sum of 1 or more distinct integer squares.\n\n      '''1''' == 1\n      '''5''' == 4 + 1\n     '''25''' == 16 + 9\n     '''77''' == 36 + 25 + 16\n    '''103''' == 49 + 25 + 16 + 9 + 4\nMany can be generated in multiple ways:\n\n     '''90''' == 36 + 25 + 16 + 9 + 4 == 64 + 16 + 9 + 1 == 49 + 25 + 16 == 64 + 25 + 1 == 81 + 9\n    '''130''' == 64 + 36 + 16 + 9 + 4 + 1 == 49 + 36 + 25 + 16 + 4 == 100 + 16 + 9 + 4 + 1 == 81 + 36 + 9 + 4 == 64 + 49 + 16 + 1 == 100 + 25 + 4 + 1 == 81 + 49 == 121 + 9    \n\nThe number of positive integers that '''cannot''' be generated by any combination of distinct squares is in fact finite:\n\n    2, 3, 6, 7, etc.\n\n\n;Task\n\nFind and show here, on this page, '''every''' positive integer than cannot be generated as the sum of distinct squares.\n\nDo not use magic numbers or pre-determined limits. Justify your answer mathematically. \n\n\n;See also\n\n* OEIS: A001422 Numbers which are not the sum of distinct squares\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n \nclass Program {\n \n  // recursively permutates the list of squares to seek a matching sum\n  static bool soms(int n, IEnumerable<int> f) {\n    if (n <= 0) return false;\n    if (f.Contains(n)) return true;\n    switch(n.CompareTo(f.Sum())) {\n      case 1: return false;\n      case 0: return true;\n      case -1:\n        var rf = f.Reverse().Skip(1).ToList();\n        return soms(n - f.Last(), rf) || soms(n, rf);\n    }\n    return false;\n  }\n\n  static void Main() {\n    var sw = System.Diagnostics.Stopwatch.StartNew();\n    int c = 0, r, i, g; var s = new List<int>(); var a = new List<int>();\n    var sf = \"stopped checking after finding {0} sequential non-gaps after the final gap of {1}\";\n    for (i = 1, g = 1; g >= (i >> 1); i++) {\n      if ((r = (int)Math.Sqrt(i)) * r == i) s.Add(i);\n      if (!soms(i, s)) a.Add(g = i);\n    }\n    sw.Stop();\n    Console.WriteLine(\"Numbers which are not the sum of distinct squares:\");\n    Console.WriteLine(string.Join(\", \", a));\n    Console.WriteLine(sf, i - g, g);\n    Console.Write(\"found {0} total in {1} ms\",\n      a.Count, sw.Elapsed.TotalMilliseconds);\n  }\n}"}
{"title": "Numbers which are the cube roots of the product of their proper divisors", "language": "C#|CSharp", "task": "Example\nConsider the number 24. Its proper divisors are: 1, 2, 3, 4, 6, 8 and 12. Their product is 13,824 and the cube root of this is 24. So 24 satisfies the definition in the task title.\n\n;Task\nCompute and show here the first '''50''' positive integers which are the cube roots of the product of their proper divisors.\n\nAlso show the '''500th''' and '''5,000th''' such numbers.\n\n;Stretch\nCompute and show the '''50,000th''' such number.\n\n;Reference\n* OEIS:A111398 - Numbers which are the cube roots of the product of their proper divisors.\n\n;Note\nOEIS considers 1 to be the first number in this sequence even though, strictly speaking, it has no proper divisors. Please therefore do likewise.\n\n", "solution": "using System;\nclass Program {\n\n  static bool dc8(uint n) {\n    uint res = 1, count, p, d;\n    for ( ; (n & 1) == 0; n >>= 1) res++;\n    for (count = 1; n % 3 == 0; n /= 3) count++;\n    for (p = 5, d = 4; p * p <= n; p += d = 6 - d)\n        for (res *= count, count = 1; n % p == 0; n /= p) count++;\n    return n > 1 ? res * count == 4 : res * count == 8;\n  }\n\n  static void Main(string[] args) {\n    Console.WriteLine(\"First 50 numbers which are the cube roots of the products of \"\n                      + \"their proper divisors:\");\n    for (uint n = 1, count = 0, lmt = 500; count < 5e6; ++n) if (n == 1 || dc8(n))\n        if (++count <= 50) Console.Write(\"{0,3}{1}\",n, count % 10 == 0 ? '\\n' : ' ');\n        else if (count == lmt) Console.Write(\"{0,16:n0}th: {1:n0}\\n\", count, n, lmt *= 10);\n  }\n}"}
{"title": "Old lady swallowed a fly", "language": "C sharp|C#", "task": "Present a program which emits the lyrics to the song   ''I Knew an Old Lady Who Swallowed a Fly'',   taking advantage of the repetitive structure of the song's lyrics. \n\nThis song has multiple versions with slightly different lyrics, so all these programs might not emit identical output.\n\n\n\n", "solution": "using System;\n\nnamespace OldLady\n{\n    internal class Program\n    {\n        private const string reason = \"She swallowed the {0} to catch the {1}\";\n        private static readonly string[] creatures = {\"fly\", \"spider\", \"bird\", \"cat\", \"dog\", \"goat\", \"cow\", \"horse\"};\n\n        private static readonly string[] comments =\n        {\n            \"I don't know why she swallowed that fly.\\nPerhaps she'll die\\n\",\n            \"That wiggled and jiggled and tickled inside her\",\n            \"How absurd, to swallow a bird\",\n            \"Imagine that. She swallowed a cat\",\n            \"What a hog to swallow a dog\",\n            \"She just opened her throat and swallowed that goat\",\n            \"I don't know how she swallowed that cow\",\n            \"She's dead of course\"\n        };\n\n        private static void Main()\n        {\n            int max = creatures.Length;\n            for (int i = 0; i < max; i++)\n            {\n                Console.WriteLine(\"There was an old lady who swallowed a {0}\", creatures[i]);\n                Console.WriteLine(comments[i]);\n                for (int j = i; j > 0 && i < max - 1; j--)\n                {\n                    Console.WriteLine(reason, creatures[j], creatures[j - 1]);\n                    if (j == 1)\n                    {\n                        Console.WriteLine(comments[j - 1]);\n                    }\n                }\n            }\n            Console.Read();\n        }\n    }\n}"}
{"title": "One of n lines in a file", "language": "C sharp|C#", "task": "A method of choosing a line randomly from a file:\n::* Without reading the file more than once\n::* When substantial parts of the file cannot be held in memory\n::* Without knowing how many lines are in the file\nIs to:\n::* keep the first line of the file as a possible choice, then\n::* Read the second line of the file if possible and make it the possible choice if a uniform random value between zero and one is less than 1/2.\n::* Read the third line of the file if possible and make it the possible choice if a uniform random value between zero and one is less than 1/3.\n::* ...\n::* Read the Nth line of the file if possible and make it the possible choice if a uniform random value between zero and one is less than 1/N\n\n::* Return the computed possible choice when no further lines exist in the file.\n\n\n;Task:\n# Create a function/method/routine called one_of_n that given n, the number of actual lines in a file, follows the algorithm above to return an integer - the line number of the line chosen from the file. The number returned can vary, randomly, in each run.\n# Use one_of_n in a ''simulation'' to find what would be the chosen line of a 10-line file simulated 1,000,000 times.\n# Print and show how many times each of the 10 lines is chosen as a rough measure of how well the algorithm works.\n\n\nNote: You may choose a smaller number of repetitions if necessary, but mention this up-front.\n\nNote: This is a specific version of a Reservoir Sampling algorithm: https://en.wikipedia.org/wiki/Reservoir_sampling\n\n", "solution": "class Program\n    {\n        private static Random rnd = new Random();\n        public static int one_of_n(int n)\n        {\n            int currentChoice = 1;\n            for (int i = 2; i <= n; i++)\n            {\n                double outerLimit = 1D / (double)i;\n                if (rnd.NextDouble() < outerLimit)\n                    currentChoice = i;\n            }\n            return currentChoice;\n        }\n\n        static void Main(string[] args)\n        {\n            Dictionary<int, int> results = new Dictionary<int, int>();\n            for (int i = 1; i < 11; i++)\n                results.Add(i, 0);\n\n            for (int i = 0; i < 1000000; i++)\n            {\n                int result = one_of_n(10);\n                results[result] = results[result] + 1;\n            }\n\n            for (int i = 1; i < 11; i++)\n                Console.WriteLine(\"{0}\\t{1}\", i, results[i]);\n            Console.ReadLine();\n        }\n    }\n"}
{"title": "Operator precedence", "language": "C sharp|C#", "task": "Operators in C and C++}}\n\n\n;Task:\nProvide a list of   [[wp:order of operations|precedence   and   associativity   of all the operators and constructs that the language utilizes in descending order of precedence such that an operator which is listed on some row will be evaluated prior to any operator that is listed on a row further below it. \n\nOperators that are in the same cell (there may be several rows of operators listed in a cell) are evaluated with the same level of precedence, in the given direction. \n\nState whether arguments are passed by value or by reference.\n\n", "solution": "[http://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/ MSDN documentation]\n\n"}
{"title": "Palindrome dates", "language": "C sharp", "task": "Today   ('''2020-02-02''',   at the time of this writing)   happens to be a palindrome,   without the hyphens,   not only for those countries which express their dates in the   '''yyyy-mm-dd'''   format but,   unusually,   also for countries which use the   '''dd-mm-yyyy'''   format.\n\n\n;Task\nWrite a program which calculates and shows the next 15 palindromic dates for those countries which express their dates in the   '''yyyy-mm-dd'''   format.\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\npublic class Program\n{\n    static void Main()\n    {\n        foreach (var date in PalindromicDates(2021).Take(15)) WriteLine(date.ToString(\"yyyy-MM-dd\"));\n    }\n\n    public static IEnumerable<DateTime> PalindromicDates(int startYear) {\n        for (int y = startYear; ; y++) {\n            int m = Reverse(y % 100);\n            int d = Reverse(y / 100);\n            if (IsValidDate(y, m, d, out var date)) yield return date;\n        }\n\n        int Reverse(int x) => x % 10 * 10 + x / 10;\n        bool IsValidDate(int y, int m, int d, out DateTime date) => DateTime.TryParse($\"{y}-{m}-{d}\", out date);\n    }\n}"}
{"title": "Pangram checker", "language": "C sharp|C#", "task": "A pangram is a sentence that contains all the letters of the English alphabet at least once.\n\nFor example:   ''The quick brown fox jumps over the lazy dog''.\n\n\n;Task:\nWrite a function or method to check a sentence to see if it is a   pangram   (or not)   and show its use.\n\n\n;Related tasks:\n:*   determine if a string has all the same characters\n:*   determine if a string has all unique characters\n\n", "solution": "using System;\n\nnamespace PangrammChecker\n{\n    public class PangrammChecker\n    {\n        public static bool IsPangram(string str)\n        {\n            bool[] isUsed = new bool[26];\n            int ai = (int)'a';\n            int total = 0;\n            for (CharEnumerator en = str.ToLower().GetEnumerator(); en.MoveNext(); )\n            {\n                int d = (int)en.Current - ai;\n                if (d >= 0 && d < 26)\n                    if (!isUsed[d])\n                    {\n                        isUsed[d] = true;\n                        total++;\n                    }\n            }\n            return (total == 26);\n        }\n    }\n\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            string str1 = \"The quick brown fox jumps over the lazy dog.\";\n            string str2 = \"The qu1ck brown fox jumps over the lazy d0g.\";\n            Console.WriteLine(\"{0} is {1}a pangram\", str1,\n                PangrammChecker.IsPangram(str1)?\"\":\"not \");\n            Console.WriteLine(\"{0} is {1}a pangram\", str2,\n                PangrammChecker.IsPangram(str2)?\"\":\"not \");\n            Console.WriteLine(\"Press Return to exit\");\n            Console.ReadLine();\n        }\n    }\n}"}
{"title": "Parsing/RPN calculator algorithm", "language": "C sharp|C#", "task": "Create a stack-based evaluator for an expression in   reverse Polish notation (RPN)   that also shows the changes in the stack as each individual token is processed ''as a table''.\n\n\n* Assume an input of a correct, space separated, string of tokens of an RPN expression\n* Test with the RPN expression generated from the   [[Parsing/Shunting-yard algorithm]]   task: \n         3 4 2 * 1 5 - 2 3 ^ ^ / +  \n* Print or display the output here\n\n\n;Notes:\n*    '''^'''    means exponentiation in the expression above.\n*    '''/'''    means division.\n\n\n;See also:\n*   [[Parsing/Shunting-yard algorithm]] for a method of generating an RPN from an infix expression.\n*   Several solutions to [[24 game/Solve]] make use of RPN evaluators (although tracing how they work is not a part of that task).\n*   [[Parsing/RPN to infix conversion]].\n*   [[Arithmetic evaluation]].\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Globalization;\nusing System.Threading;\n\nnamespace RPNEvaluator\n{\n    class RPNEvaluator\n    {\n        static void Main(string[] args)\n        {\n            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;\n\n            string rpn = \"3 4 2 * 1 5 - 2 3 ^ ^ / +\";\n            Console.WriteLine(\"{0}\\n\", rpn);\n\n            decimal result = CalculateRPN(rpn);\n            Console.WriteLine(\"\\nResult is {0}\", result);\n        }\n\n        static decimal CalculateRPN(string rpn)\n        {\n            string[] rpnTokens = rpn.Split(' ');\n            Stack<decimal> stack = new Stack<decimal>();\n            decimal number = decimal.Zero;\n\n            foreach (string token in rpnTokens)\n            {\n                if (decimal.TryParse(token, out number))\n                {\n                    stack.Push(number);\n                }\n                else\n                {\n                    switch (token)\n                    {\n                        case \"^\":\n                        case \"pow\":\n                            {\n                                number = stack.Pop();\n                                stack.Push((decimal)Math.Pow((double)stack.Pop(), (double)number));\n                                break;\n                            }\n                        case \"ln\":\n                            {\n                                stack.Push((decimal)Math.Log((double)stack.Pop(), Math.E));\n                                break;\n                            }\n                        case \"sqrt\":\n                            {\n                                stack.Push((decimal)Math.Sqrt((double)stack.Pop()));\n                                break;\n                            }\n                        case \"*\":\n                            {\n                                stack.Push(stack.Pop() * stack.Pop());\n                                break;\n                            }\n                        case \"/\":\n                            {\n                                number = stack.Pop();\n                                stack.Push(stack.Pop() / number);\n                                break;\n                            }\n                        case \"+\":\n                            {\n                                stack.Push(stack.Pop() + stack.Pop());\n                                break;\n                            }\n                        case \"-\":\n                            {\n                                number = stack.Pop();\n                                stack.Push(stack.Pop() - number);\n                                break;\n                            }\n                        default:\n                            Console.WriteLine(\"Error in CalculateRPN(string) Method!\");\n                            break;\n                    }\n                }\n                PrintState(stack);\n            }\n\n            return stack.Pop();\n        }\n\n        static void PrintState(Stack<decimal> stack)\n        {\n            decimal[] arr = stack.ToArray();\n\n            for (int i = arr.Length - 1; i >= 0; i--)\n            {\n                Console.Write(\"{0,-8:F3}\", arr[i]);\n            }\n            \n            Console.WriteLine();\n        }\n    }\n}"}
{"title": "Parsing/RPN to infix conversion", "language": "C sharp|C# from Java", "task": "Create a program that takes an infix notation.\n\n* Assume an input of a correct, space separated, string of tokens\n* Generate a space separated output string representing the same expression in infix notation\n* Show how the major datastructure of your algorithm changes with each new token parsed.\n* Test with the following input RPN strings then print and display the output here.\n:::::{| class=\"wikitable\"\n! RPN input !! sample output\n|- || align=\"center\"\n| 3 4 2 * 1 5 - 2 3 ^ ^ / +|| 3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3\n|- || align=\"center\"\n| 1 2 + 3 4 + ^ 5 6 + ^|| ( ( 1 + 2 ) ^ ( 3 + 4 ) ) ^ ( 5 + 6 )\n|}\n\n* Operator precedence and operator associativity is given in this table:\n::::::::{| class=\"wikitable\"\n\n! operator !! associativity !! operation\n|- || align=\"center\" \n|                    ^   ||  4  ||  right  ||  exponentiation\n|- || align=\"center\" \n|                    *   ||  3  ||   left  ||  multiplication\n|- || align=\"center\" \n|                    /   ||  3  ||   left  ||     division\n|- || align=\"center\" \n|                    +   ||  2  ||   left  ||     addition\n|- || align=\"center\" \n|                    -   ||  2  ||   left  ||   subtraction\n|}\n\n\n;See also:\n*   [[Parsing/Shunting-yard algorithm]]   for a method of generating an RPN from an infix expression.\n*   [[Parsing/RPN calculator algorithm]]   for a method of calculating a final value from this output RPN expression.\n*   Postfix to infix   from the RubyQuiz site.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text.RegularExpressions;\n\nnamespace PostfixToInfix\n{\n    class Program\n    {\n        class Operator\n        {\n            public Operator(char t, int p, bool i = false)\n            {\n                Token = t;\n                Precedence = p;\n                IsRightAssociative = i;\n            }\n\n            public char Token { get; private set; }\n            public int Precedence { get; private set; }\n            public bool IsRightAssociative { get; private set; }\n        }\n\n        static IReadOnlyDictionary<char, Operator> operators = new Dictionary<char, Operator>\n        {\n            { '+', new Operator('+', 2) },\n            { '-', new Operator('-', 2) },\n            { '/', new Operator('/', 3) },\n            { '*', new Operator('*', 3) },\n            { '^', new Operator('^', 4, true) }\n        };\n\n        class Expression\n        {\n            public String ex;\n            public Operator op;\n\n            public Expression(String e)\n            {\n                ex = e;\n            }\n\n            public Expression(String e1, String e2, Operator o)\n            {\n                ex = String.Format(\"{0} {1} {2}\", e1, o.Token, e2);\n                op = o;\n            }\n        }\n\n        static String PostfixToInfix(String postfix)\n        {\n            var stack = new Stack<Expression>();\n\n            foreach (var token in Regex.Split(postfix, @\"\\s+\"))\n            {\n                char c = token[0];\n\n                var op = operators.FirstOrDefault(kv => kv.Key == c).Value;\n                if (op != null && token.Length == 1)\n                {\n                    Expression rhs = stack.Pop();\n                    Expression lhs = stack.Pop();\n\n                    int opPrec = op.Precedence;\n\n                    int lhsPrec = lhs.op != null ? lhs.op.Precedence : int.MaxValue;\n                    int rhsPrec = rhs.op != null ? rhs.op.Precedence : int.MaxValue;\n\n                    if ((lhsPrec < opPrec || (lhsPrec == opPrec && c == '^')))\n                        lhs.ex = '(' + lhs.ex + ')';\n\n                    if ((rhsPrec < opPrec || (rhsPrec == opPrec && c != '^')))\n                        rhs.ex = '(' + rhs.ex + ')';\n\n                    stack.Push(new Expression(lhs.ex, rhs.ex, op));\n                }\n                else\n                {\n                    stack.Push(new Expression(token));\n                }\n\n                // print intermediate result\n                Console.WriteLine(\"{0} -> [{1}]\", token,\n                    string.Join(\", \", stack.Reverse().Select(e => e.ex)));\n            }\n            return stack.Peek().ex;\n        }\n\n        static void Main(string[] args)\n        {\n            string[] inputs = { \"3 4 2 * 1 5 - 2 3 ^ ^ / +\", \"1 2 + 3 4 + ^ 5 6 + ^\" };\n            foreach (var e in inputs)\n            {\n                Console.WriteLine(\"Postfix : {0}\", e);\n                Console.WriteLine(\"Infix : {0}\", PostfixToInfix(e));\n                Console.WriteLine(); ;\n            }\n            Console.ReadLine();\n        }\n    }\n}"}
{"title": "Parsing/Shunting-yard algorithm", "language": "C sharp 7.0", "task": "Given the operator characteristics and input from the Shunting-yard algorithm page and tables, use the algorithm to show the changes in the operator stack and RPN output\nas each individual token is processed.\n\n* Assume an input of a correct, space separated, string of tokens representing an infix expression\n* Generate a space separated output string representing the RPN\n* Test with the input string:\n::::  3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3  \n* print and display the output here.\n* Operator precedence is given in this table:\n:{| class=\"wikitable\"\n\n! operator !! associativity !! operation\n|- || align=\"center\"\n|                     ^   ||  4  ||  right  ||  exponentiation \n|- || align=\"center\" \n|                     *   ||  3  ||  left   ||  multiplication\n|- || align=\"center\" \n|                     /   ||  3  ||  left   ||  division\n|- || align=\"center\" \n|                     +   ||  2  ||  left   ||  addition\n|- || align=\"center\"\n|                     -   ||  2  ||  left   ||  subtraction\n|}\n\n\n;Extra credit\nAdd extra text explaining the actions and an optional comment for the action on receipt of each token.\n\n\n;Note\nThe handling of functions and arguments is not required.\n\n\n;See also:\n* [[Parsing/RPN calculator algorithm]] for a method of calculating a final value from this output RPN expression.\n* [[Parsing/RPN to infix conversion]].\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic class Program\n{\n    public static void Main() {\n        string infix = \"3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3\";\n        Console.WriteLine(infix.ToPostfix());\n    }\n}\n\npublic static class ShuntingYard\n{\n    private static readonly Dictionary<string, (string symbol, int precedence, bool rightAssociative)> operators\n        = new (string symbol, int precedence, bool rightAssociative) [] {\n            (\"^\", 4, true),\n            (\"*\", 3, false),\n            (\"/\", 3, false),\n            (\"+\", 2, false),\n            (\"-\", 2, false)\n    }.ToDictionary(op => op.symbol);\n\n    public static string ToPostfix(this string infix) {\n        string[] tokens = infix.Split(' ');\n        var stack = new Stack<string>();\n        var output = new List<string>();\n        foreach (string token in tokens) {\n            if (int.TryParse(token, out _)) {\n                output.Add(token);\n                Print(token);\n            } else if (operators.TryGetValue(token, out var op1)) {\n                while (stack.Count > 0 && operators.TryGetValue(stack.Peek(), out var op2)) {\n                    int c = op1.precedence.CompareTo(op2.precedence);\n                    if (c < 0 || !op1.rightAssociative && c <= 0) {\n                        output.Add(stack.Pop());\n                    } else {\n                        break;\n                    }\n                }\n                stack.Push(token);\n                Print(token);\n            } else if (token == \"(\") {\n                stack.Push(token);\n                Print(token);\n            } else if (token == \")\") {\n                string top = \"\";\n                while (stack.Count > 0 && (top = stack.Pop()) != \"(\") {\n                    output.Add(top);\n                }\n                if (top != \"(\") throw new ArgumentException(\"No matching left parenthesis.\");\n                Print(token);\n            }\n        }\n        while (stack.Count > 0) {\n            var top = stack.Pop();\n            if (!operators.ContainsKey(top)) throw new ArgumentException(\"No matching right parenthesis.\");\n            output.Add(top);\n        }\n        Print(\"pop\");\n        return string.Join(\" \", output);\n        \n        //Yikes!\n        void Print(string action) => Console.WriteLine($\"{action + \":\",-4} {$\"stack[ {string.Join(\" \", stack.Reverse())} ]\",-18} {$\"out[ {string.Join(\" \", output)} ]\"}\");\n        //A little more readable?\n        void Print(string action) => Console.WriteLine(\"{0,-4} {1,-18} {2}\", action + \":\", $\"stack[ {string.Join(\" \", stack.Reverse())} ]\", $\"out[ {string.Join(\" \", output)} ]\");\n    }\n}"}
{"title": "Pascal's triangle/Puzzle", "language": "C sharp|C#", "task": "This puzzle involves a Pascals Triangle, also known as a Pyramid of Numbers.\n\n           [ 151]\n          [  ][  ]\n        [40][  ][  ]\n      [  ][  ][  ][  ]\n    [ X][11][ Y][ 4][ Z]\n\nEach brick of the pyramid is the sum of the two bricks situated below it.\nOf the three missing numbers at the base of the pyramid, \nthe middle one is the sum of the other two (that is, Y = X + Z).\n\n\n;Task:\nWrite a program to find a solution to this puzzle.\n\n", "solution": "using System;\n\nnamespace Pyramid_of_Numbers\n{\n        class Program\n\t{\n\t\tpublic static void Main(string[] args)\n\t\t{\n\t\t\t// Set console properties\n\t\t\tConsole.Title = \" Pyramid of Numbers  /  Pascal's triangle Puzzle\";\n\t\t\tConsole.SetBufferSize(80,1000);\n\t\t\tConsole.SetWindowSize(80,60);\n\t\t\tConsole.ForegroundColor = ConsoleColor.Green;\n\n\t\t\t\n\t\t\t// Main Program Loop\n\t\t\tConsoleKeyInfo k = new ConsoleKeyInfo('Y', ConsoleKey.Y,true,true,true);\n\t\t\twhile (k.Key == ConsoleKey.Y)\n\t\t\t{\n\t\t\t\tConsole.Clear();\n\t\t\t\t\n\t\t\t\tConsole.WriteLine(\"----------------------------------------------\");\n\t\t\t\tConsole.WriteLine(\" Pyramid of Numbers / Pascal's triangle Puzzle\");\n\t\t\t\tConsole.WriteLine(\"----------------------------------------------\");\n\t\t\t\tConsole.WriteLine();\n\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t//\n\t\t\t\t// Declare new Pyramid array\n\t\t\t\t//\n\t\t\t\tint r = 5;// Number of rows\n\t\t\t\tint [,] Pyramid = new int[r,r];\n\t\t\t\t\n\t\t\t\t// Set initial Pyramid values\n\t\t\t\tfor (int i = 0; i < r; i++)\n\t\t\t\t{\n\t\t\t\t\tfor(int j = 0; j < r; j++)\n\t\t\t\t\t{\n\t\t\t\t\t\tPyramid[i,j] = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Show info on created array\n\t\t\t\tConsole.WriteLine(\" Pyramid has \" + r + \" rows\");\n\t\t\t\tConsole.WriteLine(\"--------------------------------------------\");\n\t\t\t\t\n\t\t\t\t// Enter Pyramid values\n\t\t\t\tfor(int i = 0; i <= r-1; i++)\n\t\t\t\t{\n\t\t\t\t\tConsole.WriteLine(\" Enter \" + (i+1).ToString() + \". row values:\");\n\t\t\t\t\tConsole.WriteLine(\"--------------------------------------------\");\n\t\t\t\t\t\n\t\t\t\t\tfor(int j = 0; j < i+1; j++)\n\t\t\t\t\t{\n\t\t\t\t\t\tConsole.Write(\" \" + (j+1).ToString() + \". value = \");\n\t\t\t\t\t\tint v = int.Parse(Console.ReadLine());\n\t\t\t\t\t\t\n\t\t\t\t\t\tPyramid[i,j] = v;\n\t\t\t\t\t}\n\t\t\t\t\tConsole.WriteLine(\"--------------------------------------------\");\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t//\n\t\t\t\t// Show initial Pyramid values\n\t\t\t\t//\n\t\t\t\tConsole.WriteLine();\n\t\t\t\tConsole.WriteLine(\" Initial Pyramid Values \");\n\t\t\t\tConsole.WriteLine();\n\t\t\t\t\n\t\t\t\t// Show Pyramid values\n\t\t\t\tfor(int i = 0; i <= r-1; i++)\n\t\t\t\t{\n\t\t\t\t\tfor(int j = 0; j < i+1; j++)\n\t\t\t\t\t{\n\t\t\t\t\t\tConsole.Write(\"{0,4}\",Pyramid[i,j]);\n\t\t\t\t\t}\n\t\t\t\t\tConsole.WriteLine();\n\t\t\t\t}\n\t\t\t\tConsole.WriteLine(\"--------------------------------------------\");\n\t\t\t\t\n\t\t\t\t// Find solution\n\t\t\t\tSolve_Pyramid(Pyramid);\n\t\t\t\t\n\t\t\t\tConsole.WriteLine();\n\t\t\t\tConsole.Write(\" Start new calculation <Y/N>  . . . \");\n\t\t\t\tk = Console.ReadKey(true);\n\t\t\t}\n\t\t}\n\t\t\n                //\n                // Solve Function\n                //\n\t\tpublic static void Solve_Pyramid(int [,] Pyramid)\n\t\t{\n\t\t\tint r = 5; // Number of rows\n\t\t\t\n\t\t\t// Calculate Y\n\t\t\tint a = Pyramid[r-1,1];\n\t\t\tint b = Pyramid[r-1,3];\n\t\t\tint c = Pyramid[0,0];\n\t\t\t\n\t\t\tint y =  (c - (4*a) - (4*b))/7;\n\t\t\tPyramid[r-1,2] = y;\n\t\t\t\n\t\t\t\n\t\t\t// Create copy of Pyramid\n\t\t\tint [,] Pyramid_Copy = new int[r,r];\n\t\t\tArray.Copy(Pyramid,Pyramid_Copy,r*r);\n\t\t\t\n\t\t\tint n = 0; // solution counter\n\t\t\tfor(int x = 0; x < y + 1; x++)\n\t\t\t{\n\t\t\t\tfor(int z = 0; z < y + 1; z++)\n\t\t\t\t{\n\t\t\t\t\tif( (x+z) == y)\n\t\t\t\t\t{\n\t\t\t\t\t\tPyramid[r-1,0]   = x;\n\t\t\t\t\t\tPyramid[r-1,r-1] = z;\n\t\t\t\t\t\t\n\t\t\t\t\t\t// Recalculate Pyramid values\n\t\t\t\t\t\tfor(int i = r-1; i > 0; i--)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor(int j = 0; j < i; j++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tPyramid[i-1,j] = Pyramid[i,j]+Pyramid[i,j+1];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t// Compare Pyramid values\n\t\t\t\t\t\tbool solved = true;\n\t\t\t\t\t\tfor(int i = 0; i < r-1; i++)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor(int j = 0; j < i+1; j++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tif(Pyramid_Copy[i,j]>0)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tif(Pyramid[i,j] != Pyramid_Copy[i,j])\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tsolved = false;\n\t\t\t\t\t\t\t\t\t\ti = r;\n\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\tif(solved)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tn++;\n\t\t\t\t\t\t\tConsole.WriteLine();\n\t\t\t\t\t\t\tConsole.WriteLine(\" Solved Pyramid Values no.\" + n);\n\t\t\t\t\t\t\tConsole.WriteLine();\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t// Show Pyramid values\n\t\t\t\t\t\t\tfor(int i = 0; i <= r-1; i++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tfor(int j = 0; j < i+1; j++)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tConsole.Write(\"{0,4}\",Pyramid[i,j]);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tConsole.WriteLine();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tConsole.WriteLine();\n\t\t\t\t\t\t\tConsole.WriteLine(\" X = \" + Pyramid[r-1,0] + \"   \" +\n\t\t\t\t\t\t\t                  \" Y = \" + Pyramid[r-1,2] + \"   \" +\n\t\t\t\t\t\t\t                  \" Z = \" + Pyramid[r-1,4]);\n\t\t\t\t\t\t\tConsole.WriteLine();\n\t\t\t\t\t\t\tConsole.WriteLine(\"--------------------------------------------\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\tArray.Copy(Pyramid_Copy,Pyramid,r*r);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tif(n == 0)\n\t\t\t{\n\t\t\t\tConsole.WriteLine();\n\t\t\t\tConsole.WriteLine(\" Pyramid has no solution \");\n\t\t\t\tConsole.WriteLine();\n\t\t\t}\n\t\t}\n\t\t\n\t}\n}\n"}
{"title": "Pascal matrix generation", "language": "C sharp", "task": "A pascal matrix is a two-dimensional square matrix holding numbers from   binomial coefficients   and which can be shown as    nCr.\n\nShown below are truncated   5-by-5   matrices   M[i, j]   for   i,j   in range   0..4. \n\nA Pascal upper-triangular matrix that is populated with   jCi:\n\n[[1, 1, 1, 1, 1],\n [0, 1, 2, 3, 4],\n [0, 0, 1, 3, 6],\n [0, 0, 0, 1, 4],\n [0, 0, 0, 0, 1]]\n\n\nA Pascal lower-triangular matrix that is populated with   iCj   (the transpose of the upper-triangular matrix):\n\n[[1, 0, 0, 0, 0],\n [1, 1, 0, 0, 0],\n [1, 2, 1, 0, 0],\n [1, 3, 3, 1, 0],\n [1, 4, 6, 4, 1]]\n\n\nA Pascal symmetric matrix that is populated with   i+jCi:\n\n[[1, 1, 1, 1, 1],\n [1, 2, 3, 4, 5],\n [1, 3, 6, 10, 15],\n [1, 4, 10, 20, 35],\n [1, 5, 15, 35, 70]]\n\n\n\n;Task:\nWrite functions capable of generating each of the three forms of   n-by-n   matrices.\n\nUse those functions to display upper, lower, and symmetric Pascal   5-by-5   matrices on this page. \n\nThe output should distinguish between different matrices and the rows of each matrix   (no showing a list of 25 numbers assuming the reader should split it into rows).\n\n\n;Note:  \nThe   [[Cholesky decomposition]]   of a Pascal symmetric matrix is the Pascal lower-triangle matrix of the same size. \n\n", "solution": "using System;\n\npublic static class PascalMatrixGeneration\n{\n    public static void Main() {\n        Print(GenerateUpper(5));\n        Console.WriteLine();\n        Print(GenerateLower(5));\n        Console.WriteLine();\n        Print(GenerateSymmetric(5));\n    }\n\n    static int[,] GenerateUpper(int size) {\n        int[,] m = new int[size, size];\n        for (int c = 0; c < size; c++) m[0, c] = 1;\n        for (int r = 1; r < size; r++) {\n            for (int c = r; c < size; c++) {\n                m[r, c] = m[r-1, c-1] + m[r, c-1];\n            }\n        }\n        return m;\n    }\n\n    static int[,] GenerateLower(int size) {\n        int[,] m = new int[size, size];\n        for (int r = 0; r < size; r++) m[r, 0] = 1;\n        for (int c = 1; c < size; c++) {\n            for (int r = c; r < size; r++) {\n                m[r, c] = m[r-1, c-1] + m[r-1, c];\n            }\n        }\n        return m;\n    }\n\n    static int[,] GenerateSymmetric(int size) {\n        int[,] m = new int[size, size];\n        for (int i = 0; i < size; i++) m[0, i] = m[i, 0] = 1;\n        for (int r = 1; r < size; r++) {\n            for (int c = 1; c < size; c++) {\n                m[r, c] = m[r-1, c] + m[r, c-1];\n            }\n        }\n        return m;\n    }\n\n    static void Print(int[,] matrix) {\n        string[,] m = ToString(matrix);\n        int width = m.Cast<string>().Select(s => s.Length).Max();\n        int rows = matrix.GetLength(0), columns = matrix.GetLength(1);\n        for (int row = 0; row < rows; row++) {\n            Console.WriteLine(\"|\" + string.Join(\" \", Range(0, columns).Select(column => m[row, column].PadLeft(width, ' '))) + \"|\");\n        }\n    }\n\n    static string[,] ToString(int[,] matrix) {\n        int rows = matrix.GetLength(0), columns = matrix.GetLength(1);\n        string[,] m = new string[rows, columns];\n        for (int r = 0; r < rows; r++) {\n            for (int c = 0; c < columns; c++) {\n                m[r, c] = matrix[r, c].ToString();\n            }\n        }\n        return m;\n    }\n    \n}"}
{"title": "Password generator", "language": "C sharp|C#", "task": "Create a password generation program which will generate passwords containing random ASCII characters from the following groups:\n          lower-case letters:  a --> z\n          upper-case letters:  A --> Z\n                      digits:  0 --> 9\n  other printable characters:  !\"#$%&'()*+,-./:;<=>?@[]^_{|}~ \n  (the above character list excludes white-space, backslash and grave) \n\n\nThe generated password(s) must include   ''at least one''   (of each of the four groups):\n    lower-case letter, \n    upper-case letter,\n    digit  (numeral),   and \n    one  \"other\"  character. \n\n\nThe user must be able to specify the password length and the number of passwords to generate. \n\nThe passwords should be displayed or written to a file, one per line.\n\nThe randomness should be from a system source or library. \n\nThe program should implement a help option or button which should describe the program and options when invoked. \n\nYou may also allow the user to specify a seed value, and give the option of excluding visually similar characters.\n\nFor example:            Il1     O0     5S     2Z            where the characters are: \n::::*   capital eye, lowercase ell, the digit one\n::::*   capital oh, the digit zero \n::::*   the digit five, capital ess\n::::*   the digit two, capital zee\n\n\n", "solution": "using System;\nusing System.Linq;\n\nclass Program\n{\n    const string Lower = \"abcdefghijklmnopqrstuvwxyz\";\n    const string Upper = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n    const string Digits = \"0123456789\";\n    const string Symbols = \"!\\\"#$%&'()*+,-./:;<=>?@[]^_{|}~\";\n    static readonly string[] Full = {Lower, Upper, Digits, Symbols, Lower + Upper + Digits + Symbols};\n\n    const string Similar = \"Il1O05S2Z\";\n    static readonly string[] Excluded = Full.Select(x => new string(x.Except(Similar).ToArray())).ToArray();\n\n    static Random _rng = new Random();\n    static string[] _symbolSet = Full;\n\n    static void Main(string[] args)\n    {\n        int length = 12, count = 1;\n        try\n        {\n            foreach (var x in args.Select(arg => arg.Split(':')))\n            {\n                switch (x[0])\n                {\n                    case \"-l\": length = int.Parse(x[1]); break;\n                    case \"-c\": count = int.Parse(x[1]); break;\n                    case \"-s\": _rng = new Random(x[1].GetHashCode()); break;\n                    case \"-x\": _symbolSet = bool.Parse(x[1]) ? Excluded : Full; break;\n                    default: throw new FormatException(\"Could not parse arguments\");\n                }\n            }\n        }\n        catch { ShowUsage(); return; }\n        try\n        {\n            for (int i = 0; i < count; i++)\n                Console.WriteLine(GeneratePass(length));\n        }\n        catch (Exception ex) { Console.WriteLine(\"Error: \" + ex.Message); }\n    }\n\n    static void ShowUsage()\n    {\n        Console.WriteLine(\"Usage: PASSGEN [-l:length] [-c:count] [-s:seed] [-x:(true|false)]\");\n        Console.WriteLine(\"\\t-l: the length of the generated passwords\");\n        Console.WriteLine(\"\\t-c: the number of passwords to generate\");\n        Console.WriteLine(\"\\t-s: seed for the random number generator\");\n        Console.WriteLine(\"\\t-x: exclude similar characters: \" + Similar);\n        Console.WriteLine(\"Example: PASSGEN -l:10 -c:5 -s:\\\"Sample Seed\\\" -x:true\");\n    }\n\n    static string GeneratePass(int length)\n    {\n        var minLength = _symbolSet.Length - 1;\n        if(length < minLength)\n            throw new Exception(\"password length must be \" + minLength + \" or greater\");\n\n        int[] usesRemaining = Enumerable.Repeat(1, _symbolSet.Length).ToArray();\n        usesRemaining[minLength] = length - minLength;\n        var password = new char[length];\n        for (int ii = 0; ii < length; ii++)\n        {\n            int set = _rng.Next(0, _symbolSet.Length);\n            if (usesRemaining[set] > 0)\n            {\n                usesRemaining[set]--;\n                password[ii] = _symbolSet[set][_rng.Next(0, _symbolSet[set].Length)];\n            }\n            else ii--;\n        }\n        return new string(password);\n    }\n}"}
{"title": "Peaceful chess queen armies", "language": "C sharp|C# from D", "task": "In chess, a queen attacks positions from where it is, in straight lines up-down and left-right as well as on both its diagonals. It attacks only pieces ''not'' of its own colour.\n\n\n\n\n\\\n|\n/\n\n\n\n=\n=\n\n=\n=\n\n\n\n/\n|\n\\\n\n\n\n/\n\n|\n\n\\\n\n\n\n\n|\n\n\n\n\n\n\nThe goal of Peaceful chess queen armies is to arrange m black queens and m white queens on an n-by-n square grid, (the board), so that ''no queen attacks another of a different colour''.\n\n\n;Task:\n# Create a routine to represent two-colour queens on a 2-D board. (Alternating black/white background colours, Unicode chess pieces and other embellishments are not necessary, but may be used at your discretion).\n# Create a routine to generate at least one solution to placing m equal numbers of black and white queens on an n square board.\n# Display here results for the m=4, n=5 case.\n\n\n;References:\n* Peaceably Coexisting Armies of Queens (Pdf) by Robert A. Bosch. Optima, the Mathematical Programming Socity newsletter, issue 62.\n* A250000 OEIS\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace PeacefulChessQueenArmies {\n    using Position = Tuple<int, int>;\n\n    enum Piece {\n        Empty,\n        Black,\n        White\n    }\n\n    class Program {\n        static bool IsAttacking(Position queen, Position pos) {\n            return queen.Item1 == pos.Item1\n                || queen.Item2 == pos.Item2\n                || Math.Abs(queen.Item1 - pos.Item1) == Math.Abs(queen.Item2 - pos.Item2);\n        }\n\n        static bool Place(int m, int n, List<Position> pBlackQueens, List<Position> pWhiteQueens) {\n            if (m == 0) {\n                return true;\n            }\n            bool placingBlack = true;\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < n; j++) {\n                    var pos = new Position(i, j);\n                    foreach (var queen in pBlackQueens) {\n                        if (queen.Equals(pos) || !placingBlack && IsAttacking(queen, pos)) {\n                            goto inner;\n                        }\n                    }\n                    foreach (var queen in pWhiteQueens) {\n                        if (queen.Equals(pos) || placingBlack && IsAttacking(queen, pos)) {\n                            goto inner;\n                        }\n                    }\n                    if (placingBlack) {\n                        pBlackQueens.Add(pos);\n                        placingBlack = false;\n                    } else {\n                        pWhiteQueens.Add(pos);\n                        if (Place(m - 1, n, pBlackQueens, pWhiteQueens)) {\n                            return true;\n                        }\n                        pBlackQueens.RemoveAt(pBlackQueens.Count - 1);\n                        pWhiteQueens.RemoveAt(pWhiteQueens.Count - 1);\n                        placingBlack = true;\n                    }\n                inner: { }\n                }\n            }\n            if (!placingBlack) {\n                pBlackQueens.RemoveAt(pBlackQueens.Count - 1);\n            }\n            return false;\n        }\n\n        static void PrintBoard(int n, List<Position> blackQueens, List<Position> whiteQueens) {\n            var board = new Piece[n * n];\n\n            foreach (var queen in blackQueens) {\n                board[queen.Item1 * n + queen.Item2] = Piece.Black;\n            }\n            foreach (var queen in whiteQueens) {\n                board[queen.Item1 * n + queen.Item2] = Piece.White;\n            }\n\n            for (int i = 0; i < board.Length; i++) {\n                if (i != 0 && i % n == 0) {\n                    Console.WriteLine();\n                }\n                switch (board[i]) {\n                    case Piece.Black:\n                        Console.Write(\"B \");\n                        break;\n                    case Piece.White:\n                        Console.Write(\"W \");\n                        break;\n                    case Piece.Empty:\n                        int j = i / n;\n                        int k = i - j * n;\n                        if (j % 2 == k % 2) {\n                            Console.Write(\"  \");\n                        } else {\n                            Console.Write(\"# \");\n                        }\n                        break;\n                }\n            }\n\n            Console.WriteLine(\"\\n\");\n        }\n\n        static void Main() {\n            var nms = new int[,] {\n                {2, 1}, {3, 1}, {3, 2}, {4, 1}, {4, 2}, {4, 3},\n                {5, 1}, {5, 2}, {5, 3}, {5, 4}, {5, 5},\n                {6, 1}, {6, 2}, {6, 3}, {6, 4}, {6, 5}, {6, 6},\n                {7, 1}, {7, 2}, {7, 3}, {7, 4}, {7, 5}, {7, 6}, {7, 7},\n            };\n            for (int i = 0; i < nms.GetLength(0); i++) {\n                Console.WriteLine(\"{0} black and {0} white queens on a {1} x {1} board:\", nms[i, 1], nms[i, 0]);\n                List<Position> blackQueens = new List<Position>();\n                List<Position> whiteQueens = new List<Position>();\n                if (Place(nms[i, 1], nms[i, 0], blackQueens, whiteQueens)) {\n                    PrintBoard(nms[i, 0], blackQueens, whiteQueens);\n                } else {\n                    Console.WriteLine(\"No solution exists.\\n\");\n                }\n            }\n        }\n    }\n}"}
{"title": "Pentomino tiling", "language": "C sharp|C# from Java", "task": "A pentomino is a polyomino that consists of 5 squares. There are 12 pentomino shapes, \nif you don't count rotations and reflections. Most pentominoes can form their own mirror image through \nrotation, but some of them have to be flipped over.\n\n        I                                                                        \n        I     L       N                                                 Y        \n FF     I     L      NN     PP     TTT              V       W     X    YY      ZZ\nFF      I     L      N      PP      T     U U       V      WW    XXX    Y      Z \n F      I     LL     N      P       T     UUU     VVV     WW      X     Y     ZZ \n\n\nA Pentomino tiling is an example of an exact cover problem and can take on many forms. \nA traditional tiling presents an 8 by 8 grid, where 4 cells are left uncovered. The other cells are covered \nby the 12 pentomino shapes, without overlaps, with every shape only used once.\n\nThe 4 uncovered cells should be chosen at random. Note that not all configurations are solvable.\n\n\n;Task\nCreate an 8 by 8 tiling and print the result.\n\n\n;Example\n\nF I I I I I L N\nF F F L L L L N\nW F - X Z Z N N\nW W X X X Z N V\nT W W X - Z Z V\nT T T P P V V V\nT Y - P P U U U\nY Y Y Y P U - U\n\n\n;Related tasks\n* Free polyominoes enumeration\n\n", "solution": "using System;\nusing System.Linq;\n\nnamespace PentominoTiling\n{\n    class Program\n    {\n        static readonly char[] symbols = \"FILNPTUVWXYZ-\".ToCharArray();\n\n        static readonly int nRows = 8;\n        static readonly int nCols = 8;\n        static readonly int target = 12;\n        static readonly int blank = 12;\n\n        static int[][] grid = new int[nRows][];\n        static bool[] placed = new bool[target];\n\n        static void Main(string[] args)\n        {\n            var rand = new Random();\n\n            for (int r = 0; r < nRows; r++)\n                grid[r] = Enumerable.Repeat(-1, nCols).ToArray();\n\n            for (int i = 0; i < 4; i++)\n            {\n                int randRow, randCol;\n                do\n                {\n                    randRow = rand.Next(nRows);\n                    randCol = rand.Next(nCols);\n                } \n                while (grid[randRow][randCol] == blank);\n\n                grid[randRow][randCol] = blank;\n            }\n\n            if (Solve(0, 0))\n            {\n                PrintResult();\n            }\n            else\n            {\n                Console.WriteLine(\"no solution\");\n            }\n\n            Console.ReadKey();\n        }\n\n        private static void PrintResult()\n        {\n            foreach (int[] r in grid)\n            {\n                foreach (int i in r)\n                    Console.Write(\"{0} \", symbols[i]);\n                Console.WriteLine();\n            }\n        }\n\n        private static bool Solve(int pos, int numPlaced)\n        {\n            if (numPlaced == target)\n                return true;\n\n            int row = pos / nCols;\n            int col = pos % nCols;\n\n            if (grid[row][col] != -1)\n                return Solve(pos + 1, numPlaced);\n\n            for (int i = 0; i < shapes.Length; i++)\n            {\n                if (!placed[i])\n                {\n                    foreach (int[] orientation in shapes[i])\n                    {\n                        if (!TryPlaceOrientation(orientation, row, col, i))\n                            continue;\n\n                        placed[i] = true;\n\n                        if (Solve(pos + 1, numPlaced + 1))\n                            return true;\n\n                        RemoveOrientation(orientation, row, col);\n                        placed[i] = false;\n                    }\n                }\n            }\n            return false;\n        }\n\n        private static void RemoveOrientation(int[] orientation, int row, int col)\n        {\n            grid[row][col] = -1;\n            for (int i = 0; i < orientation.Length; i += 2)\n                grid[row + orientation[i]][col + orientation[i + 1]] = -1;\n        }\n\n        private static bool TryPlaceOrientation(int[] orientation, int row, int col, int shapeIndex)\n        {\n            for (int i = 0; i < orientation.Length; i += 2)\n            {\n                int x = col + orientation[i + 1];\n                int y = row + orientation[i];\n                if (x < 0 || x >= nCols || y < 0 || y >= nRows || grid[y][x] != -1)\n                    return false;\n            }\n\n            grid[row][col] = shapeIndex;\n            for (int i = 0; i < orientation.Length; i += 2)\n                grid[row + orientation[i]][col + orientation[i + 1]] = shapeIndex;\n\n            return true;\n        }\n\n        // four (x, y) pairs are listed, (0,0) not included\n        static readonly int[][] F = {\n            new int[] {1, -1, 1, 0, 1, 1, 2, 1}, new int[] {0, 1, 1, -1, 1, 0, 2, 0},\n            new int[] {1, 0, 1, 1, 1, 2, 2, 1}, new int[] {1, 0, 1, 1, 2, -1, 2, 0},\n            new int[] {1, -2, 1, -1, 1, 0, 2, -1}, new int[] {0, 1, 1, 1, 1, 2, 2, 1},\n            new int[] {1, -1, 1, 0, 1, 1, 2, -1}, new int[] {1, -1, 1, 0, 2, 0, 2, 1}};\n\n        static readonly int[][] I = {\n            new int[] { 0, 1, 0, 2, 0, 3, 0, 4 }, new int[] { 1, 0, 2, 0, 3, 0, 4, 0 } };\n\n        static readonly int[][] L = {\n            new int[] {1, 0, 1, 1, 1, 2, 1, 3}, new int[] {1, 0, 2, 0, 3, -1, 3, 0},\n            new int[] {0, 1, 0, 2, 0, 3, 1, 3}, new int[] {0, 1, 1, 0, 2, 0, 3, 0},\n            new int[] {0, 1, 1, 1, 2, 1, 3, 1}, new int[] {0, 1, 0, 2, 0, 3, 1, 0},\n            new int[] {1, 0, 2, 0, 3, 0, 3, 1}, new int[] {1, -3, 1, -2, 1, -1, 1, 0}};\n\n        static readonly int[][] N = {\n            new int[] {0, 1, 1, -2, 1, -1, 1, 0}, new int[] {1, 0, 1, 1, 2, 1, 3, 1},\n            new int[]  {0, 1, 0, 2, 1, -1, 1, 0}, new int[] {1, 0, 2, 0, 2, 1, 3, 1},\n            new int[] {0, 1, 1, 1, 1, 2, 1, 3}, new int[] {1, 0, 2, -1, 2, 0, 3, -1},\n            new int[] {0, 1, 0, 2, 1, 2, 1, 3}, new int[] {1, -1, 1, 0, 2, -1, 3, -1}};\n\n        static readonly int[][] P = {\n            new int[] {0, 1, 1, 0, 1, 1, 2, 1}, new int[] {0, 1, 0, 2, 1, 0, 1, 1},\n            new int[] {1, 0, 1, 1, 2, 0, 2, 1}, new int[] {0, 1, 1, -1, 1, 0, 1, 1},\n            new int[] {0, 1, 1, 0, 1, 1, 1, 2}, new int[] {1, -1, 1, 0, 2, -1, 2, 0},\n            new int[] {0, 1, 0, 2, 1, 1, 1, 2}, new int[] {0, 1, 1, 0, 1, 1, 2, 0}};\n\n        static readonly int[][] T = {\n            new int[] {0, 1, 0, 2, 1, 1, 2, 1}, new int[] {1, -2, 1, -1, 1, 0, 2, 0},\n            new int[] {1, 0, 2, -1, 2, 0, 2, 1}, new int[] {1, 0, 1, 1, 1, 2, 2, 0}};\n\n        static readonly int[][] U = {\n            new int[] {0, 1, 0, 2, 1, 0, 1, 2}, new int[] {0, 1, 1, 1, 2, 0, 2, 1},\n            new int[]  {0, 2, 1, 0, 1, 1, 1, 2}, new int[] {0, 1, 1, 0, 2, 0, 2, 1}};\n\n        static readonly int[][] V = {\n            new int[] {1, 0, 2, 0, 2, 1, 2, 2}, new int[] {0, 1, 0, 2, 1, 0, 2, 0},\n            new int[] {1, 0, 2, -2, 2, -1, 2, 0}, new int[] {0, 1, 0, 2, 1, 2, 2, 2}};\n\n        static readonly int[][] W = {\n            new int[] {1, 0, 1, 1, 2, 1, 2, 2}, new int[] {1, -1, 1, 0, 2, -2, 2, -1},\n            new int[] {0, 1, 1, 1, 1, 2, 2, 2}, new int[] {0, 1, 1, -1, 1, 0, 2, -1}};\n\n        static readonly int[][] X = { new int[] { 1, -1, 1, 0, 1, 1, 2, 0 } };\n\n        static readonly int[][] Y = {\n            new int[] {1, -2, 1, -1, 1, 0, 1, 1}, new int[] {1, -1, 1, 0, 2, 0, 3, 0},\n            new int[] {0, 1, 0, 2, 0, 3, 1, 1}, new int[] {1, 0, 2, 0, 2, 1, 3, 0},\n            new int[] {0, 1, 0, 2, 0, 3, 1, 2}, new int[] {1, 0, 1, 1, 2, 0, 3, 0},\n            new int[] {1, -1, 1, 0, 1, 1, 1, 2}, new int[] {1, 0, 2, -1, 2, 0, 3, 0}};\n\n        static readonly int[][] Z = {\n            new int[] {0, 1, 1, 0, 2, -1, 2, 0}, new int[] {1, 0, 1, 1, 1, 2, 2, 2},\n            new int[] {0, 1, 1, 1, 2, 1, 2, 2}, new int[] {1, -2, 1, -1, 1, 0, 2, -2}};\n\n        static readonly int[][][] shapes = { F, I, L, N, P, T, U, V, W, X, Y, Z };\n    }\n}"}
{"title": "Perfect shuffle", "language": "C sharp 6", "task": "A perfect shuffle (or faro/weave shuffle) means splitting a deck of cards into equal halves, and perfectly interleaving them - so that you end up with the first card from the left half, followed by the first card from the right half, and so on:\n\n\n\n::: 7 8 9 J Q K-7  8  9  J  Q  K-7 J 8 Q 9 K\n\n\n\nWhen you repeatedly perform perfect shuffles on an even-sized deck of unique cards, it will at some point arrive back at its original order. How many shuffles this takes, depends solely on the number of cards in the deck - for example for a deck of eight cards it takes three shuffles:\n\n\n\n::::: {| style=\"border-spacing:0.5em 0;border-collapse:separate;margin:0 1em;text-align:right\"\n|-\n| ''original:'' ||\n1\n2\n3\n4\n5\n6\n7\n8\n|-\n| ''after 1st shuffle:'' ||\n1\n5\n2\n6\n3\n7\n4\n8\n|-\n| ''after 2nd shuffle:'' ||\n1\n3\n5\n7\n2\n4\n6\n8\n|-\n| ''after 3rd shuffle:'' ||\n1\n2\n3\n4\n5\n6\n7\n8\n|}\n\n\n'''''The Task'''''\n\n# Write a function that can perform a perfect shuffle on an even-sized list of values.\n# Call this function repeatedly to count how many shuffles are needed to get a deck back to its original order, for each of the deck sizes listed under \"Test Cases\" below.\n#* You can use a list of numbers (or anything else that's convenient) to represent a deck; just make sure that all \"cards\" are unique within each deck.\n#* Print out the resulting shuffle counts, to demonstrate that your program passes the test-cases.\n'''''Test Cases'''''\n\n::::: {| class=\"wikitable\"\n|-\n! input ''(deck size)'' !! output ''(number of shuffles required)''\n|-\n| 8 || 3\n|-\n| 24 || 11\n|-\n| 52 || 8\n|-\n| 100 || 30\n|-\n| 1020 || 1018\n|-\n| 1024 || 10\n|-\n| 10000 || 300\n|}\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic static class PerfectShuffle\n{\n    static void Main()\n    {\n        foreach (int input in new [] {8, 24, 52, 100, 1020, 1024, 10000}) {\n            int[] numbers = Enumerable.Range(1, input).ToArray();\n            Console.WriteLine($\"{input} cards: {ShuffleThrough(numbers).Count()}\");\n        }\n\n        IEnumerable<T[]> ShuffleThrough<T>(T[] original) {\n            T[] copy = (T[])original.Clone();\n            do {\n                yield return copy = Shuffle(copy);\n            } while (!Enumerable.SequenceEqual(original, copy));\n        }\n    }\n\n    public static T[] Shuffle<T>(T[] array) {\n        if (array.Length % 2 != 0) throw new ArgumentException(\"Length must be even.\");\n        int half = array.Length / 2;\n        T[] result = new T[array.Length];\n        for (int t = 0, l = 0, r = half; l < half; t+=2, l++, r++) {\n            result[t] = array[l];\n            result[t+1] = array[r];\n        }\n        return result;\n    }\n    \n}"}
{"title": "Permutations/Derangements", "language": "C sharp|C#", "task": "A derangement is a permutation of the order of distinct items in which ''no item appears in its original place''.\n\nFor example, the only two derangements of the three items (0, 1, 2) are (1, 2, 0), and (2, 0, 1).\n\nThe number of derangements of ''n'' distinct items is known as the subfactorial of ''n'', sometimes written as !''n''. \nThere are various ways to calculate !''n''.\n\n\n;Task:\n# Create a named function/method/subroutine/... to generate derangements of the integers ''0..n-1'', (or ''1..n'' if you prefer). \n# Generate ''and show'' all the derangements of 4 integers using the above routine.\n# Create a function that calculates the subfactorial of ''n'', !''n''.\n# Print and show a table of the ''counted'' number of derangements of ''n'' vs. the calculated !''n'' for n from 0..9 inclusive.\n\n\n;Optional stretch goal:\n*   Calculate    !''20'' \n\n\n;Related tasks:\n*   [[Anagrams/Deranged anagrams]]\n*   [[Best shuffle]]\n*   [[Left_factorials]]\n\n\n\n", "solution": "using System;\nclass Derangements\n{\n  static int n = 4;\n  static int [] buf = new int [n];\n  static bool [] used = new bool [n];\n\n  static void Main()\n  {\n    for (int i = 0; i < n; i++) used [i] = false;\n    rec(0);\n  }\n\n  static void rec(int ind)\n  {\n    for (int i = 0; i < n; i++)\n    {\n      if (!used [i] && i != ind)\n      {\n        used [i] = true;\n        buf [ind] = i;\n\tif (ind + 1 < n) rec(ind + 1);\n        else Console.WriteLine(string.Join(\",\", buf));\n\tused [i] = false;\n      }\n    }\n  }\n}\n"}
{"title": "Phrase reversals", "language": "C sharp", "task": "Given a string of space separated words containing the following phrase:\n  rosetta code phrase reversal\n\n:# Reverse the characters of the string.\n:# Reverse the characters of each individual word in the string, maintaining original word order within the string.\n:# Reverse the order of each word of the string, maintaining the order of characters in each word.\n\nShow your output here.\n \n\n\n", "solution": "using System;\nusing System.Linq;\nnamespace ConsoleApplication\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            //Reverse() is an extension method on IEnumerable<char>.\n            //The constructor takes a char[], so we have to call ToArray()\n            Func<string, string> reverse = s => new string(s.Reverse().ToArray());\n\n            string phrase = \"rosetta code phrase reversal\";\n            //Reverse the string\n            Console.WriteLine(reverse(phrase));\n            //Reverse each individual word in the string, maintaining original string order.\n            Console.WriteLine(string.Join(\" \", phrase.Split(' ').Select(word => reverse(word))));\n            //Reverse the order of each word of the phrase, maintaining the order of characters in each word.\n            Console.WriteLine(string.Join(\" \", phrase.Split(' ').Reverse()));\n        }\n    }\n}"}
{"title": "Pig the dice game", "language": "C sharp", "task": "The   game of Pig   is a multiplayer game played with a single six-sided die.   The\nobject of the game is to reach   '''100'''   points or more.   \nPlay is taken in turns.   On each person's turn that person has the option of either:\n\n:# '''Rolling the dice''':   where a roll of two to six is added to their score for that turn and the player's turn continues as the player is given the same choice again;   or a roll of   '''1'''   loses the player's total points   ''for that turn''   and their turn finishes with play passing to the next player.\n:# '''Holding''':   the player's score for that round is added to their total and becomes safe from the effects of throwing a   '''1'''   (one).   The player's turn finishes with play passing to the next player.\n\n\n;Task:\nCreate a program to score for, and simulate dice throws for, a two-person game. \n\n\n;Related task:\n*   [[Pig the dice game/Player]]\n\n", "solution": "using System;\nusing System.IO;\n\nnamespace Pig {\n\n\tclass Roll {\n\t\tpublic int TotalScore{get;set;}\n\t\tpublic int RollScore{get;set;}\n\t\tpublic bool Continue{get;set;}\n\t}\n\n\tclass Player {\n\t\tpublic String Name{get;set;}\n\t\tpublic int Score {get;set;}\n\t\tRandom rand;\n\n\t\tpublic Player() {\n\t\t\tScore = 0;\n\t\t\trand = new Random();\n\t\t}\n\n\t\tpublic Roll Roll(int LastScore){\n\t\t\tRoll roll = new Roll();\n\t\t\troll.RollScore = rand.Next(6) + 1;\n\n\t\t\tif(roll.RollScore == 1){\n\t\t\t\troll.TotalScore = 0;\n\t\t\t\troll.Continue = false;\n\t\t\t\treturn roll;\n\t\t\t}\n\n\t\t\troll.TotalScore = LastScore + roll.RollScore;\n\t\t\troll.Continue = true;\n\t\t\treturn roll;\n\t\t}\n\n\t\tpublic void FinalizeTurn(Roll roll){\n\t\t\tScore = Score + roll.TotalScore;\n\t\t}\n\t}\n\n\tpublic class Game {\t\t\n\t\tpublic static void Main(String[] argv){\n\t\t\tString input = null;\n\t\t\tPlayer[] players = new Player[2];\n\n\t\t\t// Game loop\n\t\t\twhile(true){\t\t\t\t\t\t\t\t\n\t\t\t\tConsole.Write(\"Greetings! Would you like to play a game (y/n)?\");\n\t\t\t\twhile(input == null){\n\t\t\t\t\tinput = Console.ReadLine();\n\t\t\t\t\tif(input.ToLowerInvariant() == \"y\"){\n\t\t\t\t\t\tplayers[0] = new Player();\n\t\t\t\t\t\tplayers[1] = new Player();\n\t\t\t\t\t\tConsole.Write(\"Player One, what's your name?\");\n\t\t\t\t\t\tinput = Console.ReadLine();\n\t\t\t\t\t\tplayers[0].Name = input;\n\t\t\t\t\t\tConsole.Write(\"Player Two, what's your name?\");\n\t\t\t\t\t\tinput = Console.ReadLine();\n\t\t\t\t\t\tplayers[1].Name = input;\n\t\t\t\t\t\tConsole.WriteLine(players[0].Name + \" and \" + players[1].Name + \", prepare to do battle!\");\n\t\t\t\t\t} else if (input.ToLowerInvariant() == \"n\"){\n\t\t\t\t\t\tgoto Goodbye; /* Not considered harmful */\n\t\t\t\t\t} else {\n\t\t\t\t\t\tinput = null;\n\t\t\t\t\t\tConsole.Write(\"I'm sorry, I don't understand. Play a game (y/n)?\");\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Play the game\n\t\t\t\tint currentPlayer = 0;\n\t\t\t\tRoll roll = null;\n\t\t\t\tbool runTurn = true;\n\t\t\t\twhile(runTurn){\n\t\t\t\t\tPlayer p = players[currentPlayer];\n\t\t\t\t\troll = p.Roll( (roll !=null) ? roll.TotalScore : 0 );\n\t\t\t\t\tif(roll.Continue){\n\t\t\t\t\t\tif(roll.TotalScore + p.Score > 99){\n\t\t\t\t\t\t\tConsole.WriteLine(\"Congratulations, \" + p.Name + \"! You rolled a \" + roll.RollScore + \" for a final score of \" + (roll.TotalScore + p.Score) + \"!\");\n\t\t\t\t\t\t\trunTurn = false;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tConsole.Write(p.Name + \": Roll \" + roll.RollScore + \"/Turn \" + roll.TotalScore + \"/Total \" + (roll.TotalScore + p.Score) + \". Roll again (y/n)?\");\n\t\t\t\t\t\t\tinput = Console.ReadLine();\n\t\t\t\t\t\t\tif(input.ToLowerInvariant() == \"y\"){\n\t\t\t\t\t\t\t\t// Do nothing\n\t\t\t\t\t\t\t} else if (input.ToLowerInvariant() == \"n\"){\n\t\t\t\t\t\t\t\tp.FinalizeTurn(roll);\n\t\t\t\t\t\t\t\tcurrentPlayer = Math.Abs(currentPlayer - 1);\t\t\t\n\t\t\t\t\t\t\t\tConsole.WriteLine();\n\t\t\t\t\t\t\tConsole.WriteLine(players[0].Name + \": \" + players[0].Score + \"    \" + players[1].Name + \": \" + players[1].Score);\t\t\t\t\t\n\t\t\t\t\t\t\t\tConsole.WriteLine(players[currentPlayer].Name + \", your turn begins.\");\n\t\t\t\t\t\t\t\troll = null;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tinput = null;\n\t\t\t\t\t\t\t\tConsole.Write(\"I'm sorry, I don't understand. Play a game (y/n)?\");\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tConsole.WriteLine(p.Name + @\", you rolled a 1 and lost your points for this turn.\nYour current score:\t\" + p.Score);\n\t\t\t\t\t\tConsole.WriteLine();\n\t\t\t\t\t\tConsole.WriteLine(players[0].Name + \": \" + players[0].Score + \"    \" + players[1].Name + \": \" + players[1].Score);\n\t\t\t\t\t\tcurrentPlayer = Math.Abs(currentPlayer - 1);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\n\t\t\t\tinput = null;\n\t\t\t}\n\t\t\tGoodbye:\n\t\t\tConsole.WriteLine(\"Thanks for playing, and remember: the house ALWAYS wins!\");\n\t\t\tSystem.Environment.Exit(0);\n\t\t}\n\t}\n}\n"}
{"title": "Poker hand analyser", "language": "C sharp 8", "task": "Create a program to parse a single five card poker hand and rank it according to this list of poker hands.\n\n\nA poker hand is specified as a space separated list of five playing cards. \n\nEach input card has two characters indicating face and suit. \n\n\n;Example:\n::::'''2d'''       (two of diamonds).\n\n\n\nFaces are:    '''a''', '''2''', '''3''', '''4''', '''5''', '''6''', '''7''', '''8''', '''9''', '''10''', '''j''', '''q''', '''k'''\n\nSuits are:    '''h''' (hearts),   '''d''' (diamonds),   '''c''' (clubs),   and   '''s''' (spades),   or \nalternatively,   the unicode card-suit characters:         \n\n\nDuplicate cards are illegal.\n\nThe program should analyze a single hand and produce one of the following outputs:\n  straight-flush\n  four-of-a-kind\n  full-house\n  flush\n  straight\n  three-of-a-kind\n  two-pair\n  one-pair\n  high-card\n  invalid\n\n\n;Examples:\n    2 2 2 k q:   three-of-a-kind\n    2 5 7 8 9:   high-card\n    a 2 3 4 5:   straight\n    2 3 2 3 3:   full-house\n    2 7 2 3 3:   two-pair\n    2 7 7 7 7:   four-of-a-kind \n    10 j q k a:  straight-flush\n    4 4 k 5 10:  one-pair\n    q 10 7 6 q:  invalid\n\nThe programs output for the above examples should be displayed here on this page.\n\n\n;Extra credit:\n# use the playing card characters introduced with Unicode 6.0 (U+1F0A1 - U+1F0DE).\n# allow two jokers\n::* use the symbol   '''joker'''\n::* duplicates would be allowed (for jokers only)\n::* five-of-a-kind would then be the highest hand\n\n\n;More extra credit examples:\n    joker  2  2  k  q:     three-of-a-kind\n    joker  5  7  8  9:     straight\n    joker  2  3  4  5:     straight\n    joker  3  2  3  3:     four-of-a-kind\n    joker  7  2  3  3:     three-of-a-kind\n    joker  7  7  7  7:     five-of-a-kind\n    joker  j  q  k  A:     straight-flush\n    joker  4  k  5 10:     one-pair\n    joker  k  7  6  4:     flush\n    joker  2  joker  4  5:  straight\n    joker  Q  joker  A 10:  straight\n    joker  Q  joker  A 10:  straight-flush\n    joker  2  2  joker  q:  four-of-a-kind\n\n\n;Related tasks:\n* [[Playing cards]]\n* [[Card shuffles]]\n* [[Deal cards_for_FreeCell]]\n* [[War Card_Game]]\n* [[Go Fish]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing static System.Linq.Enumerable;\n\npublic static class PokerHandAnalyzer\n{\n    private enum Hand {\n        Invalid, High_Card, One_Pair, Two_Pair, Three_Of_A_Kind, Straight,\n        Flush, Full_House, Four_Of_A_Kind, Straight_Flush, Five_Of_A_Kind\n    }\n\n    private const bool Y = true;\n    private const char C = '\u2663', D = '\u2666', H = '\u2665', S = '\u2660';\n    private const int rankMask = 0b11_1111_1111_1111;\n    private const int suitMask = 0b1111 << 14;\n    private static readonly string[] ranks = { \"a\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\", \"j\", \"q\", \"k\" };\n    private static readonly string[] suits = { C + \"\", D + \"\", H + \"\", S + \"\" };\n    private static readonly Card[] deck = (from suit in Range(1, 4) from rank in Range(1, 13) select new Card(rank, suit)).ToArray();\n\n    public static void Main() {\n        string[] hands = {\n            \"2\u2665 2\u2666 2\u2663 k\u2663 q\u2666\",\n            \"2\u2665 5\u2665 7\u2666 8\u2663 9\u2660\",\n            \"a\u2665 2\u2666 3\u2663 4\u2663 5\u2666\",\n            \"2\u2665 3\u2665 2\u2666 3\u2663 3\u2666\",\n            \"2\u2665 7\u2665 2\u2666 3\u2663 3\u2666\",\n            \"2\u2665 7\u2665 7\u2666 7\u2663 7\u2660\",\n            \"10\u2665 j\u2665 q\u2665 k\u2665 a\u2665\",\n            \"4\u2665 4\u2660 k\u2660 5\u2666 10\u2660\",\n            \"q\u2663 10\u2663 7\u2663 6\u2663 4\u2663\",\n            \"4\u2665 4\u2663 4\u2665 4\u2660 4\u2666\", //duplicate card\n            \"joker 2\u2666 2\u2660 k\u2660 q\u2666\",\n            \"joker 5\u2665 7\u2666 8\u2660 9\u2666\",\n            \"joker 2\u2666 3\u2660 4\u2660 5\u2660\",\n            \"joker 3\u2665 2\u2666 3\u2660 3\u2666\",\n            \"joker 7\u2665 2\u2666 3\u2660 3\u2666\",\n            \"joker 7\u2665 7\u2666 7\u2660 7\u2663\",\n            \"joker j\u2665 q\u2665 k\u2665 A\u2665\",\n            \"joker 4\u2663 k\u2663 5\u2666 10\u2660\",\n            \"joker k\u2663 7\u2663 6\u2663 4\u2663\",\n            \"joker 2\u2666 joker 4\u2660 5\u2660\",\n            \"joker Q\u2666 joker A\u2660 10\u2660\",\n            \"joker Q\u2666 joker A\u2666 10\u2666\",\n            \"joker 2\u2666 2\u2660 joker q\u2666\"\n        };\n        foreach (var h in hands) {\n            Console.WriteLine($\"{h}: {Analyze(h).Name()}\");\n        }\n    }\n\n    static string Name(this Hand hand) => string.Join('-', hand.ToString().Split('_')).ToLower();\n\n    static List<T> With<T>(this List<T> list, int index, T item) {\n        list[index] = item;\n        return list;\n    }\n\n    struct Card : IEquatable<Card>, IComparable<Card>\n    {\n        public static readonly Card Invalid = new Card(-1, -1);\n        public static readonly Card Joker = new Card(0, 0);\n\n        public Card(int rank, int suit) {\n            (Rank, Suit, Code) = (rank, suit) switch {\n                (_, -1) => (-1, -1, -1),\n                (-1, _) => (-1, -1, -1),\n                (0, _) => (0, 0, 0),\n                (1, _) => (rank, suit, (1 << (13 + suit)) | ((1 << 13) | 1)),\n                (_, _) => (rank, suit, (1 << (13 + suit)) | (1 << (rank - 1)))\n            };\n        }\n\n        public static implicit operator Card((int rank, int suit) tuple) => new Card(tuple.rank, tuple.suit);\n        public int Rank { get; }\n        public int Suit { get; }\n        public int Code { get; }\n\n        public override string ToString() => Rank switch {\n            -1 => \"invalid\",\n            0 => \"joker\",\n            _ => $\"{ranks[Rank-1]}{suits[Suit-1]}\"\n        };\n        \n        public override int GetHashCode() => Rank << 16 | Suit;\n        public bool Equals(Card other) => Rank == other.Rank && Suit == other.Suit;\n\n        public int CompareTo(Card other) {\n            int c = Rank.CompareTo(other.Rank);\n            if (c != 0) return c;\n            return Suit.CompareTo(other.Suit);\n        }\n    }\n\n    static Hand Analyze(string hand) {\n        var cards = ParseHand(hand);\n        if (cards.Count != 5) return Hand.Invalid; //hand must consist of 5 cards\n        cards.Sort();\n        if (cards[0].Equals(Card.Invalid)) return Hand.Invalid;\n        int jokers = cards.LastIndexOf(Card.Joker) + 1;\n        if (jokers > 2) return Hand.Invalid; //more than 2 jokers\n        if (cards.Skip(jokers).Distinct().Count() + jokers != 5) return Hand.Invalid; //duplicate cards\n\n        if (jokers == 2) return (from c0 in deck from c1 in deck select Evaluate(cards.With(0, c0).With(1, c1))).Max();\n        if (jokers == 1) return (from c0 in deck select Evaluate(cards.With(0, c0))).Max();\n        return Evaluate(cards);\n    }\n\n    static List<Card> ParseHand(string hand) =>\n        hand.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries)\n        .Select(card => ParseCard(card.ToLower())).ToList();\n\n    static Card ParseCard(string card) => (card.Length, card) switch {\n        (5, \"joker\") => Card.Joker,\n        (3, _) when card[..2] == \"10\" => (10, ParseSuit(card[2])),\n        (2, _) => (ParseRank(card[0]), ParseSuit(card[1])),\n        (_, _) => Card.Invalid\n    };\n\n    static int ParseRank(char rank) => rank switch {\n        'a' => 1,\n        'j' => 11,\n        'q' => 12,\n        'k' => 13,\n        _ when rank >= '2' && rank <= '9' => rank - '0',\n        _ => -1\n    };\n\n    static int ParseSuit(char suit) => suit switch {\n        C => 1, 'c' => 1,\n        D => 2, 'd' => 2,\n        H => 3, 'h' => 3,\n        S => 4, 's' => 4,\n        _ => -1\n    };\n\n    static Hand Evaluate(List<Card> hand) {\n        var frequencies = hand.GroupBy(c => c.Rank).Select(g => g.Count()).OrderByDescending(c => c).ToArray();\n        (int f0, int f1) = (frequencies[0], frequencies.Length > 1 ? frequencies[1] : 0);\n\n        return (IsFlush(), IsStraight(), f0, f1) switch {\n            (_, _, 5, _) => Hand.Five_Of_A_Kind,\n            (Y, Y, _, _) => Hand.Straight_Flush,\n            (_, _, 4, _) => Hand.Four_Of_A_Kind,\n            (_, _, 3, 2) => Hand.Full_House,\n            (Y, _, _, _) => Hand.Flush,\n            (_, Y, _, _) => Hand.Straight,\n            (_, _, 3, _) => Hand.Three_Of_A_Kind,\n            (_, _, 2, 2) => Hand.Two_Pair,\n            (_, _, 2, _) => Hand.One_Pair,\n                        _ => Hand.High_Card\n        };\n\n        bool IsFlush() => hand.Aggregate(suitMask, (r, c) => r & c.Code) > 0;\n\n        bool IsStraight() {\n            int r = hand.Aggregate(0, (r, c) => r | c.Code) & rankMask;\n            for (int i = 0; i < 4; i++) r &= r << 1;\n            return r > 0;\n        }\n    }\n    \n}"}
{"title": "Polyspiral", "language": "C sharp|C# from Java", "task": "A Polyspiral is a spiral made of multiple line segments, whereby each segment is larger (or smaller) than the previous one by a given amount. Each segment also changes direction at a given angle. \n\n\n;Task\nAnimate a series of polyspirals, by drawing a complete spiral then incrementing the angle, and (after clearing the background) drawing the next, and so on. Every spiral will be a frame of the animation. The animation may stop as it goes full circle or continue indefinitely. The given input values may be varied.\n\nIf animation is not practical in your programming environment, you may show a single frame instead.\n\n\n;Pseudo code\n\n    set incr to 0.0\n\n    // animation loop\n    WHILE true \n\n        incr = (incr + 0.05) MOD 360\n        x = width / 2\n        y = height / 2\n        length = 5\n        angle = incr\n\n        // spiral loop\n        FOR 1 TO 150\n            drawline\n            change direction by angle\n            length = length + 3\n            angle = (angle + incr) MOD 360\n        ENDFOR\n    \n\n\n", "solution": "using System;\nusing System.Drawing;\nusing System.Drawing.Drawing2D;\nusing System.Windows.Forms;\nusing System.Windows.Threading;\n\nnamespace Polyspiral\n{\n    public partial class Form1 : Form\n    {\n        private double inc;\n\n        public Form1()\n        {\n            Width = Height = 640;\n            StartPosition = FormStartPosition.CenterScreen;\n            SetStyle(\n                ControlStyles.AllPaintingInWmPaint |\n                ControlStyles.UserPaint |\n                ControlStyles.DoubleBuffer,\n                true);\n\n            var timer = new DispatcherTimer();\n            timer.Tick += (s, e) => { inc = (inc + 0.05) % 360; Refresh(); };\n            timer.Interval = new TimeSpan(0, 0, 0, 0, 40);\n            timer.Start();\n        }\n\n        private void DrawSpiral(Graphics g, int len, double angleIncrement)\n        {\n            double x1 = Width / 2;\n            double y1 = Height / 2;\n            double angle = angleIncrement;\n\n            for (int i = 0; i < 150; i++)\n            {\n                double x2 = x1 + Math.Cos(angle) * len;\n                double y2 = y1 - Math.Sin(angle) * len;\n                g.DrawLine(Pens.Blue, (int)x1, (int)y1, (int)x2, (int)y2);\n                x1 = x2;\n                y1 = y2;\n\n                len += 3;\n\n                angle = (angle + angleIncrement) % (Math.PI * 2);\n            }\n        }\n\n        protected override void OnPaint(PaintEventArgs args)\n        {\n            var g = args.Graphics;\n            g.SmoothingMode = SmoothingMode.AntiAlias;\n            g.Clear(Color.White);\n\n            DrawSpiral(g, 5, ToRadians(inc));\n        }\n\n        private double ToRadians(double angle)\n        {\n            return Math.PI * angle / 180.0;\n        }\n    }\n}"}
{"title": "Population count", "language": "C sharp|C#", "task": "The   ''population count''   is the number of   '''1'''s   (ones)   in the binary representation of a non-negative integer.\n\n''Population count''   is also known as:\n::::*   ''pop count''\n::::*   ''popcount'' \n::::*   ''sideways sum''\n::::*   ''bit summation'' \n::::*   ''Hamming weight'' \n\n\nFor example,   '''5'''   (which is   '''101'''   in binary)   has a population count of   '''2'''.\n\n\n''Evil numbers''   are non-negative integers  that have an   ''even''   population count.\n\n''Odious numbers''      are  positive integers that have an    ''odd''   population count.\n\n\n;Task:\n* write a function (or routine) to return the population count of a non-negative integer.\n* all computation of the lists below should start with   '''0'''   (zero indexed).\n:* display the   ''pop count''   of the   1st   thirty powers of   '''3'''       ('''30''',   '''31''',   '''32''',   '''33''',   '''34''',      '''329''').\n:* display the   1st   thirty     ''evil''        numbers.\n:* display the   1st   thirty          ''odious''           numbers.\n* display each list of integers on one line   (which may or may not include a title),   each set of integers being shown should be properly identified.\n\n\n;See also\n* The On-Line Encyclopedia of Integer Sequences:   A000120 population count.\n* The On-Line Encyclopedia of Integer Sequences:   A000069 odious numbers.\n* The On-Line Encyclopedia of Integer Sequences:   A001969 evil numbers.\n\n", "solution": "using System;\nusing System.Linq;\n\nnamespace PopulationCount\n{\n    class Program\n    {\n        private static int PopulationCount(long n)\n        {\n            string binaryn = Convert.ToString(n, 2);\n            return binaryn.ToCharArray().Where(t => t == '1').Count();\n        }\n\n        static void Main(string[] args)\n        {\n            Console.WriteLine(\"Population Counts:\");\n            Console.Write(\"3^n :   \");\n\n            int count = 0;\n\n            while (count < 30)\n            {\n                double n = Math.Pow(3f, (double)count);\n                int popCount = PopulationCount((long)n);\n                Console.Write(string.Format(\"{0} \", popCount));\n                count++;\n            }\n\n            Console.WriteLine();\n            Console.Write(\"Evil:   \");\n\n            count = 0;\n            int i = 0;\n\n            while (count < 30)\n            {\n                int popCount = PopulationCount(i);\n\n                if (popCount % 2 == 0)\n                {\n                    count++;\n                    Console.Write(string.Format(\"{0} \", i));\n                }\n\n                i++;\n            }\n\n            Console.WriteLine();\n            Console.Write(\"Odious: \");\n\n            count = 0;\n            i = 0;\n\n            while (count < 30)\n            {\n                int popCount = PopulationCount(i);\n\n                if (popCount % 2 != 0)\n                {\n                    count++;\n                    Console.Write(string.Format(\"{0} \", i));\n                }\n\n                i++;\n            }\n\n            Console.ReadKey();\n        }\n    }\n}\n"}
{"title": "Priority queue", "language": "C sharp", "task": "A queue, with an important distinction: each item is added to a priority queue with a priority level, and will be later removed from the queue with the highest priority element first. That is, the items are (conceptually) stored in the queue in priority order instead of in insertion order.\n\n\n;Task:\nCreate a priority queue.   The queue must support at least two operations:\n:#   Insertion.   An element is added to the queue with a priority (a numeric value).\n:#   Top item removal.   Deletes the element or one of the elements with the current top priority and return it.\n\n\nOptionally, other operations may be defined, such as peeking (find what current top priority/top element is), merging (combining two priority queues into one), etc.\n\n\nTo test your implementation, insert a number of elements into the queue, each with some random priority. \n\nThen dequeue them sequentially; now the elements should be sorted by priority. \n\nYou can use the following task/priority items as input data:\n         '''Priority'''         '''Task'''\n        ----------   ----------------\n            3         Clear drains\n            4         Feed cat\n            5         Make tea\n            1         Solve RC tasks\n            2         Tax return\n\n\nThe implementation should try to be efficient.   A typical implementation has   '''O(log n)'''   insertion and extraction time,   where   '''n'''   is the number of items in the queue.  \n\nYou may choose to impose certain limits such as small range of allowed priority levels, limited capacity, etc.   If so, discuss the reasons behind it.\n\n", "solution": "namespace PriorityQ {\n  using KeyT = UInt32;\n  using System;\n  using System.Collections.Generic;\n  using System.Linq;\n  class Tuple<K, V> { // for DotNet 3.5 without Tuple's\n    public K Item1; public V Item2;\n    public Tuple(K k, V v) { Item1 = k; Item2 = v; }\n    public override string ToString() {\n      return \"(\" + Item1.ToString() + \", \" + Item2.ToString() + \")\";\n    }\n  }\n  class MinHeapPQ<V> {\n    private struct HeapEntry {\n      public KeyT k; public V v;\n      public HeapEntry(KeyT k, V v) { this.k = k; this.v = v; }\n    }\n    private List<HeapEntry> pq;\n    private MinHeapPQ() { this.pq = new List<HeapEntry>(); }\n    private bool mt { get { return pq.Count == 0; } }\n    private int sz {\n      get {\n        var cnt = pq.Count;\n        return (cnt == 0) ? 0 : cnt - 1;\n      }\n    }\n    private Tuple<KeyT, V> pkmn {\n      get {\n        if (pq.Count == 0) return null;\n        else {\n          var mn = pq[0];\n          return new Tuple<KeyT, V>(mn.k, mn.v);\n        }\n      }\n    }\n    private void psh(KeyT k, V v) { // add extra very high item if none\n      if (pq.Count == 0) pq.Add(new HeapEntry(UInt32.MaxValue, v));\n      var i = pq.Count; pq.Add(pq[i - 1]); // copy bottom item...\n      for (var ni = i >> 1; ni > 0; i >>= 1, ni >>= 1) {\n        var t = pq[ni - 1];\n        if (t.k > k) pq[i - 1] = t; else break;\n      }\n      pq[i - 1] = new HeapEntry(k, v);\n    }\n    private void siftdown(KeyT k, V v, int ndx) {\n      var cnt = pq.Count - 1; var i = ndx;\n      for (var ni = i + i + 1; ni < cnt; ni = ni + ni + 1) {\n        var oi = i; var lk = pq[ni].k; var rk = pq[ni + 1].k;\n        var nk = k;\n        if (k > lk) { i = ni; nk = lk; }\n        if (nk > rk) { ni += 1; i = ni; }\n        if (i != oi) pq[oi] = pq[i]; else break;\n      }\n      pq[i] = new HeapEntry(k, v);\n    }\n    private void rplcmin(KeyT k, V v) {\n      if (pq.Count > 1) siftdown(k, v, 0);\n    }\n    private void dltmin() {\n      var lsti = pq.Count - 2;\n      if (lsti <= 0) pq.Clear();\n      else {\n        var lkv = pq[lsti];\n        pq.RemoveAt(lsti); siftdown(lkv.k, lkv.v, 0);\n      }\n    }\n    private void reheap(int i) {\n      var lfti = i + i + 1;\n      if (lfti < sz) {\n        var rghti = lfti + 1; reheap(lfti); reheap(rghti);\n        var ckv = pq[i]; siftdown(ckv.k, ckv.v, i);\n      }\n    }\n    private void bld(IEnumerable<Tuple<KeyT, V>> sq) {\n      var sqm = from e in sq\n                select new HeapEntry(e.Item1, e.Item2);\n      pq = sqm.ToList<HeapEntry>();\n      var sz = pq.Count;\n      if (sz > 0) {\n        var lkv = pq[sz - 1];\n        pq.Add(new HeapEntry(KeyT.MaxValue, lkv.v));\n        reheap(0);\n      }\n    }\n    private IEnumerable<Tuple<KeyT, V>> sq() {\n      return from e in pq\n             where e.k != KeyT.MaxValue\n             select new Tuple<KeyT, V>(e.k, e.v); }\n    private void adj(Func<KeyT, V, Tuple<KeyT, V>> f) {\n      var cnt = pq.Count - 1;\n      for (var i = 0; i < cnt; ++i) {\n        var e = pq[i];\n        var r = f(e.k, e.v);\n        pq[i] = new HeapEntry(r.Item1, r.Item2);\n      }\n      reheap(0);\n    }\n    public static MinHeapPQ<V> empty { get { return new MinHeapPQ<V>(); } }\n    public static bool isEmpty(MinHeapPQ<V> pq) { return pq.mt; }\n    public static int size(MinHeapPQ<V> pq) { return pq.sz; }\n    public static Tuple<KeyT, V> peekMin(MinHeapPQ<V> pq) { return pq.pkmn; }\n    public static MinHeapPQ<V> push(KeyT k, V v, MinHeapPQ<V> pq) {\n      pq.psh(k, v); return pq; }\n    public static MinHeapPQ<V> replaceMin(KeyT k, V v, MinHeapPQ<V> pq) {\n      pq.rplcmin(k, v); return pq; }\n    public static MinHeapPQ<V> deleteMin(MinHeapPQ<V> pq) { pq.dltmin(); return pq; }\n    public static MinHeapPQ<V> merge(MinHeapPQ<V> pq1, MinHeapPQ<V> pq2) {\n      return fromSeq(pq1.sq().Concat(pq2.sq())); }\n    public static MinHeapPQ<V> adjust(Func<KeyT, V, Tuple<KeyT, V>> f, MinHeapPQ<V> pq) {\n      pq.adj(f); return pq; }\n    public static MinHeapPQ<V> fromSeq(IEnumerable<Tuple<KeyT, V>> sq) {\n      var pq = new MinHeapPQ<V>(); pq.bld(sq); return pq; }\n    public static Tuple<Tuple<KeyT, V>, MinHeapPQ<V>> popMin(MinHeapPQ<V> pq) {\n      var rslt = pq.pkmn; if (rslt == null) return null;\n      pq.dltmin(); return new Tuple<Tuple<KeyT, V>, MinHeapPQ<V>>(rslt, pq); }\n    public static IEnumerable<Tuple<KeyT, V>> toSeq(MinHeapPQ<V> pq) {\n      for (; !pq.mt; pq.dltmin()) yield return pq.pkmn; }\n    public static IEnumerable<Tuple<KeyT, V>> sort(IEnumerable<Tuple<KeyT, V>> sq) {\n      return toSeq(fromSeq(sq)); }\n  }\n}"}
{"title": "Pythagorean quadruples", "language": "C sharp|C# from Java", "task": "One form of   '''Pythagorean quadruples'''   is   (for positive integers   '''a''',   '''b''',   '''c''',   and   '''d'''): \n\n\n::::::::    a2   +   b2   +   c2     =     d2 \n\n\nAn example:\n\n::::::::    22   +   32   +   62     =     72 \n\n::::: which is:\n\n::::::::    4    +   9    +   36     =     49 \n\n\n;Task:\n\nFor positive integers up   '''2,200'''   (inclusive),   for all values of   '''a''',  \n'''b''',   '''c''',   and   '''d''', \nfind   (and show here)   those values of   '''d'''   that   ''can't''   be represented.\n\nShow the values of   '''d'''   on one line of output   (optionally with a title).\n\n\n;Related tasks:\n*   [[Euler's sum of powers conjecture]]. \n*   [[Pythagorean triples]].\n\n\n;Reference:\n:*   the Wikipedia article:   Pythagorean quadruple.\n\n", "solution": "using System;\n\nnamespace PythagoreanQuadruples {\n    class Program {\n        const int MAX = 2200;\n        const int MAX2 = MAX * MAX * 2;\n\n        static void Main(string[] args) {\n            bool[] found = new bool[MAX + 1]; // all false by default\n            bool[] a2b2 = new bool[MAX2 + 1]; // ditto\n            int s = 3;\n\n            for(int a = 1; a <= MAX; a++) {\n                int a2 = a * a;\n                for (int b=a; b<=MAX; b++) {\n                    a2b2[a2 + b * b] = true;\n                }\n            }\n\n            for (int c = 1; c <= MAX; c++) {\n                int s1 = s;\n                s += 2;\n                int s2 = s;\n                for (int d = c + 1; d <= MAX; d++) {\n                    if (a2b2[s1]) found[d] = true;\n                    s1 += s2;\n                    s2 += 2;\n                }\n            }\n\n            Console.WriteLine(\"The values of d <= {0} which can't be represented:\", MAX);\n            for (int d = 1; d < MAX; d++) {\n                if (!found[d]) Console.Write(\"{0}  \", d);\n            }\n            Console.WriteLine();\n        }\n    }\n}"}
{"title": "Pythagorean triples", "language": "C sharp|C#", "task": "A Pythagorean triple is defined as three positive integers (a, b, c) where a < b < c, and a^2+b^2=c^2.\n\nThey are called primitive triples if a, b, c are co-prime, that is, if their pairwise greatest common divisors {\\rm gcd}(a, b) = {\\rm gcd}(a, c) = {\\rm gcd}(b, c) = 1. \n\nBecause of their relationship through the Pythagorean theorem, a, b, and c are co-prime if a and b are co-prime ({\\rm gcd}(a, b) = 1).   \n\nEach triple forms the length of the sides of a right triangle, whose perimeter is P=a+b+c.\n\n\n;Task:\nThe task is to determine how many Pythagorean triples there are with a perimeter no larger than 100 and the number of these that are primitive.\n\n\n;Extra credit: \nDeal with large values.   Can your program handle a maximum perimeter of 1,000,000?   What about 10,000,000?   100,000,000?\n\nNote: the extra credit is not for you to demonstrate how fast your language is compared to others;   you need a proper algorithm to solve them in a timely manner.\n\n\n;Related tasks:\n*   [[Euler's sum of powers conjecture]]  \n*   [[List comprehensions]]\n*   [[Pythagorean quadruples]] \n\n", "solution": "using System;\n\nnamespace RosettaCode.CSharp\n{\n    class Program\n    {\n        static void Count_New_Triangle(ulong A, ulong B, ulong C, ulong Max_Perimeter, ref ulong Total_Cnt, ref ulong Primitive_Cnt)\n        {\n            ulong Perimeter = A + B + C;\n\n            if (Perimeter <= Max_Perimeter)\n            {\n                Primitive_Cnt = Primitive_Cnt + 1;\n                Total_Cnt = Total_Cnt + Max_Perimeter / Perimeter;\n                Count_New_Triangle(A + 2 * C - 2 * B, 2 * A + 2 * C - B, 2 * A + 3 * C - 2 * B, Max_Perimeter, ref Total_Cnt, ref Primitive_Cnt);\n                Count_New_Triangle(A + 2 * B + 2 * C, 2 * A + B + 2 * C, 2 * A + 2 * B + 3 * C, Max_Perimeter, ref Total_Cnt, ref Primitive_Cnt);\n                Count_New_Triangle(2 * B + 2 * C - A, B + 2 * C - 2 * A, 2 * B + 3 * C - 2 * A, Max_Perimeter, ref Total_Cnt, ref Primitive_Cnt);\n            }\n        }\n\n        static void Count_Pythagorean_Triples()\n        {\n            ulong T_Cnt, P_Cnt;\n\n            for (int I = 1; I <= 8; I++)\n            {\n                T_Cnt = 0;\n                P_Cnt = 0;\n                ulong ExponentNumberValue = (ulong)Math.Pow(10, I);\n                Count_New_Triangle(3, 4, 5, ExponentNumberValue, ref T_Cnt, ref P_Cnt);\n                Console.WriteLine(\"Perimeter up to 10E\" + I + \" : \" + T_Cnt + \" Triples, \" + P_Cnt + \" Primitives\");\n            }\n        }\n\n        static void Main(string[] args)\n        {\n            Count_Pythagorean_Triples();\n        }\n    }\n}"}
{"title": "Quaternion type", "language": "C sharp", "task": "complex numbers.\n\nA complex number has a real and complex part,   sometimes written as     a + bi,  \nwhere     a     and     b     stand for real numbers, and     i     stands for the square root of minus 1.\n\nAn example of a complex number might be     -3 + 2i,     \nwhere the real part,     a     is     '''-3.0'''     and the complex part,     b     is     '''+2.0'''.   \n\nA quaternion has one real part and ''three'' imaginary parts,     i,       j,     and     k.   \n\nA quaternion might be written as     a + bi + cj + dk.  \n\nIn the quaternion numbering system:\n:::*     ii = jj = kk = ijk = -1,         or more simply,\n:::*     ii  = jj  = kk  = ijk   = -1.  \n\nThe order of multiplication is important, as, in general, for two quaternions:\n::::     q1     and     q2:         q1q2  q2q1.  \n\nAn example of a quaternion might be     1 +2i +3j +4k  \n\nThere is a list form of notation where just the numbers are shown and the imaginary multipliers    i,       j,     and     k     are assumed by position. \n\nSo the example above would be written as     (1, 2, 3, 4)   \n\n\n;Task:\nGiven the three quaternions and their components:  \n    q  = (1, 2, 3, 4) = (a,  b,  c,  d)\n    q1 = (2, 3, 4, 5) = (a1, b1, c1, d1)\n    q2 = (3, 4, 5, 6) = (a2, b2, c2, d2) \nAnd a wholly real number     r = 7.  \n\n\nCreate functions   (or classes)   to perform simple maths with quaternions including computing:\n# The norm of a quaternion: = \\sqrt{a^2 + b^2 + c^2 + d^2}  \n# The negative of a quaternion:    = (-a, -b, -c, -d)  \n# The conjugate of a quaternion:    = ( a, -b, -c, -d)  \n# Addition of a real number     r     and a quaternion     q:      r + q = q + r = (a+r, b, c, d)  \n# Addition of two quaternions:    q1 + q2 = (a1+a2, b1+b2, c1+c2, d1+d2)  \n# Multiplication of a real number and a quaternion:    qr = rq = (ar, br, cr, dr)  \n# Multiplication of two quaternions     q1     and   q2     is given by:    ( a1a2 - b1b2 - c1c2 - d1d2,      a1b2 + b1a2 + c1d2 - d1c2,      a1c2 - b1d2 + c1a2 + d1b2,      a1d2 + b1c2 - c1b2 + d1a2 )  \n# Show that, for the two quaternions     q1     and     q2:  q1q2  q2q1  \n\nIf a language has built-in support for quaternions, then use it.\n\n\n;C.f.:\n*   [[Vector products]]\n*   On Quaternions;   or on a new System of Imaginaries in Algebra.   By Sir William Rowan Hamilton LL.D, P.R.I.A., F.R.A.S., Hon. M. R. Soc. Ed. and Dub., Hon. or Corr. M. of the Royal or Imperial Academies of St. Petersburgh, Berlin, Turin and Paris, Member of the American Academy of Arts and Sciences, and of other Scientific Societies at Home and Abroad, Andrews' Prof. of Astronomy in the University of Dublin, and Royal Astronomer of Ireland.\n\n", "solution": "using System;\n\nstruct Quaternion : IEquatable<Quaternion>\n{\n    public readonly double A, B, C, D;\n\n    public Quaternion(double a, double b, double c, double d)\n    {\n        this.A = a;\n        this.B = b;\n        this.C = c;\n        this.D = d;\n    }\n\n    public double Norm()\n    {\n        return Math.Sqrt(A * A + B * B + C * C + D * D);\n    }\n\n    public static Quaternion operator -(Quaternion q)\n    {\n        return new Quaternion(-q.A, -q.B, -q.C, -q.D);\n    }\n\n    public Quaternion Conjugate()\n    {\n        return new Quaternion(A, -B, -C, -D);\n    }\n\n    // implicit conversion takes care of real*quaternion and real+quaternion\n    public static implicit operator Quaternion(double d)\n    {\n        return new Quaternion(d, 0, 0, 0);\n    }\n\n    public static Quaternion operator +(Quaternion q1, Quaternion q2)\n    {\n        return new Quaternion(q1.A + q2.A, q1.B + q2.B, q1.C + q2.C, q1.D + q2.D);\n    }\n\n    public static Quaternion operator *(Quaternion q1, Quaternion q2)\n    {\n        return new Quaternion(\n            q1.A * q2.A - q1.B * q2.B - q1.C * q2.C - q1.D * q2.D,\n            q1.A * q2.B + q1.B * q2.A + q1.C * q2.D - q1.D * q2.C,\n            q1.A * q2.C - q1.B * q2.D + q1.C * q2.A + q1.D * q2.B,\n            q1.A * q2.D + q1.B * q2.C - q1.C * q2.B + q1.D * q2.A);\n    }\n\n    public static bool operator ==(Quaternion q1, Quaternion q2)\n    {\n        return q1.A == q2.A && q1.B == q2.B && q1.C == q2.C && q1.D == q2.D;\n    }\n\n    public static bool operator !=(Quaternion q1, Quaternion q2)\n    {\n        return !(q1 == q2);\n    }\n\n    #region Object Members\n\n    public override bool Equals(object obj)\n    {\n        if (obj is Quaternion)\n            return Equals((Quaternion)obj);\n\n        return false;\n    }\n\n    public override int GetHashCode()\n    {\n        return A.GetHashCode() ^ B.GetHashCode() ^ C.GetHashCode() ^ D.GetHashCode();\n    }\n\n    public override string ToString()\n    {\n        return string.Format(\"Q({0}, {1}, {2}, {3})\", A, B, C, D);\n    }\n\n    #endregion\n\n    #region IEquatable<Quaternion> Members\n\n    public bool Equals(Quaternion other)\n    {\n        return other == this;\n    }\n\n    #endregion\n}"}
{"title": "Quaternion type", "language": ".NET Core 2.1", "task": "complex numbers.\n\nA complex number has a real and complex part,   sometimes written as     a + bi,  \nwhere     a     and     b     stand for real numbers, and     i     stands for the square root of minus 1.\n\nAn example of a complex number might be     -3 + 2i,     \nwhere the real part,     a     is     '''-3.0'''     and the complex part,     b     is     '''+2.0'''.   \n\nA quaternion has one real part and ''three'' imaginary parts,     i,       j,     and     k.   \n\nA quaternion might be written as     a + bi + cj + dk.  \n\nIn the quaternion numbering system:\n:::*     ii = jj = kk = ijk = -1,         or more simply,\n:::*     ii  = jj  = kk  = ijk   = -1.  \n\nThe order of multiplication is important, as, in general, for two quaternions:\n::::     q1     and     q2:         q1q2  q2q1.  \n\nAn example of a quaternion might be     1 +2i +3j +4k  \n\nThere is a list form of notation where just the numbers are shown and the imaginary multipliers    i,       j,     and     k     are assumed by position. \n\nSo the example above would be written as     (1, 2, 3, 4)   \n\n\n;Task:\nGiven the three quaternions and their components:  \n    q  = (1, 2, 3, 4) = (a,  b,  c,  d)\n    q1 = (2, 3, 4, 5) = (a1, b1, c1, d1)\n    q2 = (3, 4, 5, 6) = (a2, b2, c2, d2) \nAnd a wholly real number     r = 7.  \n\n\nCreate functions   (or classes)   to perform simple maths with quaternions including computing:\n# The norm of a quaternion: = \\sqrt{a^2 + b^2 + c^2 + d^2}  \n# The negative of a quaternion:    = (-a, -b, -c, -d)  \n# The conjugate of a quaternion:    = ( a, -b, -c, -d)  \n# Addition of a real number     r     and a quaternion     q:      r + q = q + r = (a+r, b, c, d)  \n# Addition of two quaternions:    q1 + q2 = (a1+a2, b1+b2, c1+c2, d1+d2)  \n# Multiplication of a real number and a quaternion:    qr = rq = (ar, br, cr, dr)  \n# Multiplication of two quaternions     q1     and   q2     is given by:    ( a1a2 - b1b2 - c1c2 - d1d2,      a1b2 + b1a2 + c1d2 - d1c2,      a1c2 - b1d2 + c1a2 + d1b2,      a1d2 + b1c2 - c1b2 + d1a2 )  \n# Show that, for the two quaternions     q1     and     q2:  q1q2  q2q1  \n\nIf a language has built-in support for quaternions, then use it.\n\n\n;C.f.:\n*   [[Vector products]]\n*   On Quaternions;   or on a new System of Imaginaries in Algebra.   By Sir William Rowan Hamilton LL.D, P.R.I.A., F.R.A.S., Hon. M. R. Soc. Ed. and Dub., Hon. or Corr. M. of the Royal or Imperial Academies of St. Petersburgh, Berlin, Turin and Paris, Member of the American Academy of Arts and Sciences, and of other Scientific Societies at Home and Abroad, Andrews' Prof. of Astronomy in the University of Dublin, and Royal Astronomer of Ireland.\n\n", "solution": "Option Compare Binary\nOption Explicit On\nOption Infer On\nOption Strict On\n\nStructure Quaternion\n    Implements IEquatable(Of Quaternion), IStructuralEquatable\n\n    Public ReadOnly A, B, C, D As Double\n\n    Public Sub New(a As Double, b As Double, c As Double, d As Double)\n        Me.A = a\n        Me.B = b\n        Me.C = c\n        Me.D = d\n    End Sub\n\n    Public ReadOnly Property Norm As Double\n        Get\n            Return Math.Sqrt((Me.A ^ 2) + (Me.B ^ 2) + (Me.C ^ 2) + (Me.D ^ 2))\n        End Get\n    End Property\n\n    Public ReadOnly Property Conjugate As Quaternion\n        Get\n            Return New Quaternion(Me.A, -Me.B, -Me.C, -Me.D)\n        End Get\n    End Property\n\n    Public Overrides Function Equals(obj As Object) As Boolean\n        If TypeOf obj IsNot Quaternion Then Return False\n        Return Me.Equals(DirectCast(obj, Quaternion))\n    End Function\n\n    Public Overloads Function Equals(other As Quaternion) As Boolean Implements IEquatable(Of Quaternion).Equals\n        Return other = Me\n    End Function\n\n    Public Overloads Function Equals(other As Object, comparer As IEqualityComparer) As Boolean Implements IStructuralEquatable.Equals\n        If TypeOf other IsNot Quaternion Then Return False\n        Dim q = DirectCast(other, Quaternion)\n        Return comparer.Equals(Me.A, q.A) AndAlso\n               comparer.Equals(Me.B, q.B) AndAlso\n               comparer.Equals(Me.C, q.C) AndAlso\n               comparer.Equals(Me.D, q.D)\n    End Function\n\n    Public Overrides Function GetHashCode() As Integer\n        Return HashCode.Combine(Me.A, Me.B, Me.C, Me.D)\n    End Function\n\n    Public Overloads Function GetHashCode(comparer As IEqualityComparer) As Integer Implements IStructuralEquatable.GetHashCode\n        Return HashCode.Combine(\n            comparer.GetHashCode(Me.A),\n            comparer.GetHashCode(Me.B),\n            comparer.GetHashCode(Me.C),\n            comparer.GetHashCode(Me.D))\n    End Function\n\n    Public Overrides Function ToString() As String\n        Return $\"Q({Me.A}, {Me.B}, {Me.C}, {Me.D})\"\n    End Function\n\n#Region \"Operators\"\n    Public Shared Operator =(left As Quaternion, right As Quaternion) As Boolean\n        Return left.A = right.A AndAlso\n               left.B = right.B AndAlso\n               left.C = right.C AndAlso\n               left.D = right.D\n    End Operator\n\n    Public Shared Operator <>(left As Quaternion, right As Quaternion) As Boolean\n        Return Not left = right\n    End Operator\n\n    Public Shared Operator +(q1 As Quaternion, q2 As Quaternion) As Quaternion\n        Return New Quaternion(q1.A + q2.A, q1.B + q2.B, q1.C + q2.C, q1.D + q2.D)\n    End Operator\n\n    Public Shared Operator -(q As Quaternion) As Quaternion\n        Return New Quaternion(-q.A, -q.B, -q.C, -q.D)\n    End Operator\n\n    Public Shared Operator *(q1 As Quaternion, q2 As Quaternion) As Quaternion\n        Return New Quaternion(\n            (q1.A * q2.A) - (q1.B * q2.B) - (q1.C * q2.C) - (q1.D * q2.D),\n            (q1.A * q2.B) + (q1.B * q2.A) + (q1.C * q2.D) - (q1.D * q2.C),\n            (q1.A * q2.C) - (q1.B * q2.D) + (q1.C * q2.A) + (q1.D * q2.B),\n            (q1.A * q2.D) + (q1.B * q2.C) - (q1.C * q2.B) + (q1.D * q2.A))\n    End Operator\n\n    Public Shared Widening Operator CType(d As Double) As Quaternion\n        Return New Quaternion(d, 0, 0, 0)\n    End Operator\n#End Region\nEnd Structure"}
{"title": "Quine", "language": "C sharp", "task": "A quine is a self-referential program that can, \nwithout any external access, output its own source. \n\n\nA   '''quine'''   (named after Willard Van Orman Quine)   is also known as:\n::*   ''self-reproducing automata''        (1972)\n::*   ''self-replicating program''                             or   ''self-replicating computer program''\n::*   ''self-reproducing program''                                  or   ''self-reproducing computer program''\n::*   ''self-copying program''                       or   ''self-copying computer program''\n\n\n\nIt is named after the philosopher and logician \nwho studied self-reference and quoting in natural language, \nas for example in the paradox \"'Yields falsehood when preceded by its quotation' yields falsehood when preceded by its quotation.\"\n\n\"Source\" has one of two meanings. It can refer to the text-based program source.  \nFor languages in which program source is represented as a data structure, \"source\" may refer to the data structure: quines in these languages fall into two categories: programs which print a textual representation of themselves, or expressions which evaluate to a data structure which is equivalent to that expression.\n\nThe usual way to code a quine works similarly to this paradox: The program consists of two identical parts, once as plain code and once ''quoted'' in some way (for example, as a character string, or a literal data structure). The plain code then accesses the quoted code and prints it out twice, once unquoted and once with the proper quotation marks added. Often, the plain code and the quoted code have to be nested.\n\n\n;Task:\nWrite a program that outputs its own source code in this way. If the language allows it, you may add a variant that accesses the code directly. You are not allowed to read any external files with the source code. The program should also contain some sort of self-reference, so constant expressions which return their own value which some top-level interpreter will print out.  Empty programs producing no output are not allowed.\n\nThere are several difficulties that one runs into when writing a quine, mostly dealing with quoting:\n* Part of the code usually needs to be stored as a string or structural literal in the language, which needs to be quoted somehow. However, including quotation marks in the string literal itself would be troublesome because it requires them to be escaped, which then necessitates the escaping character (e.g. a backslash) in the string, which itself usually needs to be escaped, and so on.\n** Some languages have a function for getting the \"source code representation\" of a string (i.e. adds quotation marks, etc.); in these languages, this can be used to circumvent the quoting problem.\n** Another solution is to construct the quote character from its [[character code]], without having to write the quote character itself. Then the character is inserted into the string at the appropriate places. The ASCII code for double-quote is 34, and for single-quote is 39.\n* Newlines in the program may have to be reproduced as newlines in the string, which usually requires some kind of escape sequence (e.g. \"\\n\"). This causes the same problem as above, where the escaping character needs to itself be escaped, etc.\n** If the language has a way of getting the \"source code representation\", it usually handles the escaping of characters, so this is not a problem.\n** Some languages allow you to have a string literal that spans multiple lines, which embeds the newlines into the string without escaping.\n** Write the entire program on one line, for free-form languages (as you can see for some of the solutions here, they run off the edge of the screen), thus removing the need for newlines. However, this may be unacceptable as some languages require a newline at the end of the file; and otherwise it is still generally good style to have a newline at the end of a file. (The task is not clear on whether a newline is required at the end of the file.) Some languages have a print statement that appends a newline; which solves the newline-at-the-end issue; but others do not.\n\n\n'''Next to the Quines presented here, many other versions can be found on the Quine page.'''\n\n\n;Related task:\n:*   print itself.\n\n", "solution": "class Program { static void Main() { var s = \"class Program {{ static void Main() {{ var s = {0}{1}{0}; System.Console.WriteLine(s, (char)34, s); }} }}\"; System.Console.WriteLine(s, (char)34, s); } }"}
{"title": "RIPEMD-160", "language": "C sharp|C#", "task": "'''RIPEMD-160''' is another hash function; it computes a 160-bit message digest.\n\nThere is a RIPEMD-160 home page, with test vectors and pseudocode for RIPEMD-160. \nFor padding the message, RIPEMD-160 acts like [[MD4]] (RFC 1320).\n\nFind the RIPEMD-160 message digest of a string of [[octet]]s. \nUse the ASCII encoded string \"Rosetta Code\". \nYou may either call an RIPEMD-160 library, or implement RIPEMD-160 in your language.\n\n", "solution": "using System;\nusing System.Security.Cryptography;\nusing System.Text;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        string text = \"Rosetta Code\";\n        byte[] bytes = Encoding.ASCII.GetBytes(text);\n        RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create();\n        byte[] hashValue = myRIPEMD160.ComputeHash(bytes);\n        var hexdigest = BitConverter.ToString(hashValue).Replace(\"-\", \"\").ToLower();\n        Console.WriteLine(hexdigest);\n        Console.ReadLine();\n    }\n}"}
{"title": "RPG attributes generator", "language": "C sharp|C# from Visual Basic .NET", "task": "'''RPG'''   =   Role Playing Game.\n\n\n\nYou're running a tabletop RPG, and your players are creating characters.\n\nEach character has six core attributes: strength, dexterity, constitution, intelligence, wisdom, and charisma.\n\nOne way of generating values for these attributes is to roll four, 6-sided dice (d6) and sum the three highest rolls, discarding the lowest roll.\n\nSome players like to assign values to their attributes in the order they're rolled.\n\nTo ensure generated characters don't put players at a disadvantage, the following requirements must be satisfied:\n\n* The total of all character attributes must be at least 75.\n* At least two of the attributes must be at least 15.\n\nHowever, this can require a lot of manual dice rolling. A programatic solution would be much faster.\n\n\n;Task:\nWrite a program that:\n# Generates 4 random, whole values between 1 and 6.\n# Saves the sum of the 3 largest values.\n# Generates a total of 6 values this way.\n# Displays the total, and all 6 values once finished.\n\n* The order in which each value was generated must be preserved.\n* The total of all 6 values must be at least 75.\n* At least 2 of the values must be 15 or more.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nstatic class Module1\n{\n    static Random r = new Random();\n\n    static List<int> getThree(int n)\n    {\n        List<int> g3 = new List<int>();\n        for (int i = 0; i < 4; i++) g3.Add(r.Next(n) + 1);\n        g3.Sort(); g3.RemoveAt(0); return g3;\n    }\n\n    static List<int> getSix()\n    {\n        List<int> g6 = new List<int>();\n        for (int i = 0; i < 6; i++) g6.Add(getThree(6).Sum());\n        return g6;\n    }\n\n    static void Main(string[] args)\n    {\n        bool good = false; do {\n            List<int> gs = getSix(); int gss = gs.Sum(); int hvc = gs.FindAll(x => x > 14).Count;\n            Console.Write(\"attribs: {0}, sum={1}, ({2} sum, high vals={3})\",\n                          string.Join(\", \", gs), gss, gss >= 75 ? \"good\" : \"low\", hvc);\n            Console.WriteLine(\" - {0}\", (good = gs.Sum() >= 75 && hvc > 1) ? \"success\" : \"failure\");\n        } while (!good);\n    }\n}"}
{"title": "Ramer-Douglas-Peucker line simplification", "language": "C sharp|C# from Java", "task": "The   '''Ramer-Douglas-Peucker'''   algorithm is a line simplification algorithm for reducing the number of points used to define its shape. \n\n\n;Task:\nUsing the   '''Ramer-Douglas-Peucker'''   algorithm, simplify the   2D   line defined by the points:\n    (0,0)  (1,0.1)  (2,-0.1)  (3,5)  (4,6)  (5,7)  (6,8.1)  (7,9)  (8,9)  (9,9) \n\nThe error threshold to be used is:   '''1.0'''. \n\nDisplay the remaining points here.\n\n\n;Reference:\n:*   the Wikipedia article:   Ramer-Douglas-Peucker algorithm.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace LineSimplification {\n    using Point = Tuple<double, double>;\n\n    class Program {\n        static double PerpendicularDistance(Point pt, Point lineStart, Point lineEnd) {\n            double dx = lineEnd.Item1 - lineStart.Item1;\n            double dy = lineEnd.Item2 - lineStart.Item2;\n\n            // Normalize\n            double mag = Math.Sqrt(dx * dx + dy * dy);\n            if (mag > 0.0) {\n                dx /= mag;\n                dy /= mag;\n            }\n            double pvx = pt.Item1 - lineStart.Item1;\n            double pvy = pt.Item2 - lineStart.Item2;\n\n            // Get dot product (project pv onto normalized direction)\n            double pvdot = dx * pvx + dy * pvy;\n\n            // Scale line direction vector and subtract it from pv\n            double ax = pvx - pvdot * dx;\n            double ay = pvy - pvdot * dy;\n\n            return Math.Sqrt(ax * ax + ay * ay);\n        }\n\n        static void RamerDouglasPeucker(List<Point> pointList, double epsilon, List<Point> output) {\n            if (pointList.Count < 2) {\n                throw new ArgumentOutOfRangeException(\"Not enough points to simplify\");\n            }\n\n            // Find the point with the maximum distance from line between the start and end\n            double dmax = 0.0;\n            int index = 0;\n            int end = pointList.Count - 1;\n            for (int i = 1; i < end; ++i) {\n                double d = PerpendicularDistance(pointList[i], pointList[0], pointList[end]);\n                if (d > dmax) {\n                    index = i;\n                    dmax = d;\n                }\n            }\n\n            // If max distance is greater than epsilon, recursively simplify\n            if (dmax > epsilon) {\n                List<Point> recResults1 = new List<Point>();\n                List<Point> recResults2 = new List<Point>();\n                List<Point> firstLine = pointList.Take(index + 1).ToList();\n                List<Point> lastLine = pointList.Skip(index).ToList();\n                RamerDouglasPeucker(firstLine, epsilon, recResults1);\n                RamerDouglasPeucker(lastLine, epsilon, recResults2);\n\n                // build the result list\n                output.AddRange(recResults1.Take(recResults1.Count - 1));\n                output.AddRange(recResults2);\n                if (output.Count < 2) throw new Exception(\"Problem assembling output\");\n            }\n            else {\n                // Just return start and end points\n                output.Clear();\n                output.Add(pointList[0]);\n                output.Add(pointList[pointList.Count - 1]);\n            }\n        }\n\n        static void Main(string[] args) {\n            List<Point> pointList = new List<Point>() {\n                new Point(0.0,0.0),\n                new Point(1.0,0.1),\n                new Point(2.0,-0.1),\n                new Point(3.0,5.0),\n                new Point(4.0,6.0),\n                new Point(5.0,7.0),\n                new Point(6.0,8.1),\n                new Point(7.0,9.0),\n                new Point(8.0,9.0),\n                new Point(9.0,9.0),\n            };\n            List<Point> pointListOut = new List<Point>();\n            RamerDouglasPeucker(pointList, 1.0, pointListOut);\n            Console.WriteLine(\"Points remaining after simplification:\");\n            pointListOut.ForEach(p => Console.WriteLine(p));\n        }\n    }\n}"}
{"title": "Random Latin squares", "language": "C sharp|C# from Kotlin", "task": "A Latin square of size n is an arrangement of n symbols  in an n-by-n square in such a way that each row and column has each symbol appearing exactly once.\nFor the purposes of this task, a random Latin square of size n is a Latin square constructed or generated by a probabilistic procedure such that the probability of any particular Latin square of size n being produced is non-zero.\n\n;Example n=4 randomised Latin square:\n0 2 3 1\n2 1 0 3\n3 0 1 2\n1 3 2 0\n\n;Task:\n# Create a function/routine/procedure/method/... that given n generates a randomised Latin square of size n.\n# Use the function to generate ''and show here'', two randomly generated squares of size 5.\n\n;Note: \nStrict ''uniformity'' in the random generation is a hard problem and '''not''' a requirement of the task.\n\n;Related tasks:\n* [[Latin Squares in reduced form/Randomizing using Jacobson and Matthews' Technique]]\n* [[Latin Squares in reduced form]]\n\n;Reference:\n* Wikipedia: Latin square\n* OEIS: A002860\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace RandomLatinSquares {\n    using Matrix = List<List<int>>;\n\n    // Taken from https://stackoverflow.com/a/1262619\n    static class Helper {\n        private static readonly Random rng = new Random();\n\n        public static void Shuffle<T>(this IList<T> list) {\n            int n = list.Count;\n            while (n > 1) {\n                n--;\n                int k = rng.Next(n + 1);\n                T value = list[k];\n                list[k] = list[n];\n                list[n] = value;\n            }\n        }\n    }\n\n    class Program {\n        static void PrintSquare(Matrix latin) {\n            foreach (var row in latin) {\n                Console.Write('[');\n\n                var it = row.GetEnumerator();\n                if (it.MoveNext()) {\n                    Console.Write(it.Current);\n                }\n                while (it.MoveNext()) {\n                    Console.Write(\", \");\n                    Console.Write(it.Current);\n                }\n\n                Console.WriteLine(']');\n            }\n            Console.WriteLine();\n        }\n\n        static void LatinSquare(int n) {\n            if (n <= 0) {\n                Console.WriteLine(\"[]\");\n                return;\n            }\n\n            var latin = new Matrix();\n            for (int i = 0; i < n; i++) {\n                List<int> temp = new List<int>();\n                for (int j = 0; j < n; j++) {\n                    temp.Add(j);\n                }\n                latin.Add(temp);\n            }\n            // first row\n            latin[0].Shuffle();\n\n            // middle row(s)\n            for (int i = 1; i < n - 1; i++) {\n                bool shuffled = false;\n\n                while (!shuffled) {\n                    latin[i].Shuffle();\n                    for (int k = 0; k < i; k++) {\n                        for (int j = 0; j < n; j++) {\n                            if (latin[k][j] == latin[i][j]) {\n                                goto shuffling;\n                            }\n                        }\n                    }\n                    shuffled = true;\n\n                shuffling: { }\n                }\n            }\n\n            // last row\n            for (int j = 0; j < n; j++) {\n                List<bool> used = new List<bool>();\n                for (int i = 0; i < n; i++) {\n                    used.Add(false);\n                }\n\n                for (int i = 0; i < n-1; i++) {\n                    used[latin[i][j]] = true;\n                }\n                for (int k = 0; k < n; k++) {\n                    if (!used[k]) {\n                        latin[n - 1][j] = k;\n                        break;\n                    }\n                }\n            }\n\n            PrintSquare(latin);\n        }\n\n        static void Main() {\n            LatinSquare(5);\n            LatinSquare(5);\n            LatinSquare(10); // for good measure\n        }\n    }\n}"}
{"title": "Random number generator (device)", "language": "C sharp", "task": "If your system has a means to generate random numbers involving not only a software algorithm   (like the /dev/urandom devices in Unix),   then:\n\nshow how to obtain a random 32-bit number from that mechanism.\n\n;Related task\n* [[Random_number_generator_(included)]]\n\n", "solution": "const long m = 2147483647L;\nconst long a = 48271L;\nconst long q = 44488L;\nconst long r = 3399L;\nstatic long r_seed = 12345678L;\n\npublic static byte gen()\n{\n   long hi = r_seed / q;\n   long lo = r_seed - q * hi;\n   long t = a * lo - r * hi;\n       if (t > 0)\n           r_seed = t;\n       else\n           r_seed = t + m;\n       return (byte)r_seed;\n}\n\npublic static void ParkMiller(byte[] arr)\n{\n   byte[] arr = new byte[10900000];\n    for (int i = 0; i < arr.Length; i++)\n                {                       \n                       arr[i] = gen();\n                }\n}"}
{"title": "Random number generator (included)", "language": "C sharp", "task": "The task is to:\n: State the type of random number generator algorithm used in a language's built-in random number generator. If the language or its immediate libraries don't provide a random number generator, skip this task.\n: If possible, give a link to a wider explanation of the algorithm used.\n\nNote: the task is ''not'' to create an RNG, but to report on the languages in-built RNG that would be the most likely RNG used.\n\nThe main types of pseudo-random number generator (Mersenne twister generator is a subclass). The last main type is where the output of one of the previous ones (typically a Mersenne twister) is fed through a [[cryptographic hash function]] to maximize unpredictability of individual bits. \n\nNote that neither LCGs nor GFSRs should be used for the most demanding applications (cryptography) without additional steps.\n\n", "solution": "The .NET Random class says that it uses Knuth's subtractive random number generator algorithm.[http://msdn.microsoft.com/en-us/library/system.random.aspx#remarksToggle]\n\n"}
{"title": "Range consolidation", "language": "C sharp 7", "task": "Define a range of numbers   '''R''',   with bounds   '''b0'''   and   '''b1'''   covering all numbers ''between and including both bounds''. \n\n\nThat range can be shown as:\n::::::::: '''[b0, b1]'''\n::::::::    or equally as:\n::::::::: '''[b1, b0]'''\n\n\nGiven two ranges, the act of consolidation between them compares the two ranges:\n*   If one range covers all of the other then the result is that encompassing range.\n*   If the ranges touch or intersect then the result is   ''one''   new single range covering the overlapping ranges.\n*   Otherwise the act of consolidation is to return the two non-touching ranges.\n\n\nGiven   '''N'''   ranges where   '''N > 2'''   then the result is the same as repeatedly replacing all combinations of two ranges by their consolidation until no further consolidation between range pairs is possible. \n\nIf   '''N < 2'''   then range consolidation has no strict meaning and the input can be returned. \n\n\n;Example 1:\n:   Given the two ranges   '''[1, 2.5]'''   and   '''[3, 4.2]'''   then \n:   there is no common region between the ranges and the result is the same as the input.\n\n\n;Example 2:\n:   Given the two ranges   '''[1, 2.5]'''   and   '''[1.8, 4.7]'''   then \n:   there is :   an overlap   '''[2.5, 1.8]'''   between the ranges and \n:   the result is the single range   '''[1, 4.7]'''.  \n:   Note that order of bounds in a range is not (yet) stated.\n\n\n;Example 3:\n:   Given the two ranges   '''[6.1, 7.2]'''   and   '''[7.2, 8.3]'''   then \n:   they touch at   '''7.2'''   and \n:   the result is the single range   '''[6.1, 8.3]'''. \n\n\n;Example 4:\n:   Given the three ranges   '''[1, 2]'''   and   '''[4, 8]'''   and   '''[2, 5]''' \n:   then there is no intersection of the ranges   '''[1, 2]'''   and   '''[4, 8]''' \n:   but the ranges   '''[1, 2]'''   and   '''[2, 5]'''   overlap and \n:   consolidate to produce the range   '''[1, 5]'''. \n:   This range, in turn, overlaps the other range   '''[4, 8]''',   and \n:   so consolidates to the final output of the single range   '''[1, 8]'''.\n\n\n;Task:\nLet a normalized range display show the smaller bound to the left;   and show the\nrange with the smaller lower bound to the left of other ranges when showing multiple ranges.\n\nOutput the ''normalized'' result of applying consolidation to these five sets of ranges: \n            [1.1, 2.2]\n            [6.1, 7.2], [7.2, 8.3]\n            [4, 3], [2, 1]\n            [4, 3], [2, 1], [-1, -2], [3.9, 10]\n            [1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]  \nShow all output here.\n\n\n;See also:\n* [[Set consolidation]]\n* [[Set of real numbers]]\n\n", "solution": "using static System.Math;\nusing System.Linq;\nusing System;\n\npublic static class RangeConsolidation\n{\n    public static void Main() {\n        foreach (var list in new [] {\n            new[] { (1.1, 2.2) }.ToList(),\n            new[] { (6.1, 7.2), (7.2, 8.3) }.ToList(),\n            new[] { (4d, 3d), (2, 1) }.ToList(),\n            new[] { (4d, 3d), (2, 1), (-1, 2), (3.9, 10) }.ToList(),\n            new[] { (1d, 3d), (-6, -1), (-4, -5), (8, 2), (-6, -6) }.ToList()\n        })\n        {\n            for (int z = list.Count-1; z >= 1; z--) {\n                for (int y = z - 1; y >= 0; y--) {\n                    if (Overlap(list[z], list[y])) {\n                        list[y] = Consolidate(list[z], list[y]);\n                        list.RemoveAt(z);\n                        break;\n                    }\n                }\n            }\n            Console.WriteLine(string.Join(\", \", list.Select(Normalize).OrderBy(range => range.s)));\n        }\n    }\n\n    private static bool Overlap((double s, double e) left, (double s, double e) right) =>\n        Max(left.s, left.e) > Max(right.s, right.e)\n        ? Max(right.s, right.e) >= Min(left.s, left.e)\n        : Max(left.s, left.e) >= Min(right.s, right.e);\n\n    private static (double s, double e) Consolidate((double s, double e) left, (double s, double e) right) =>\n        (Min(Min(left.s, left.e), Min(right.s, right.e)), Max(Max(left.s, left.e), Max(right.s, right.e)));\n    \n    private static (double s, double e) Normalize((double s, double e) range) =>\n        (Min(range.s, range.e), Max(range.s, range.e));\n}"}
{"title": "Range expansion", "language": "C sharp 3.0", "task": "{{:Range extraction/Format}}\n\n\n;Task:\nExpand the range description: \n   -6,-3--1,3-5,7-11,14,15,17-20 \nNote that the second element above, \nis the '''range from minus 3 to ''minus'' 1'''. \n\n\n;Related task:\n*   [[Range extraction]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text.RegularExpressions;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        var rangeString = \"-6,-3--1,3-5,7-11,14,15,17-20\";\n        var matches = Regex.Matches(rangeString, @\"(?<f>-?\\d+)-(?<s>-?\\d+)|(-?\\d+)\");\n        var values = new List<string>();\n\n        foreach (var m in matches.OfType<Match>())\n        {\n            if (m.Groups[1].Success)\n            {\n                values.Add(m.Value);\n                continue;\n            }\n\n            var start = Convert.ToInt32(m.Groups[\"f\"].Value);\n            var end = Convert.ToInt32(m.Groups[\"s\"].Value) + 1;\n\n            values.AddRange(Enumerable.Range(start, end - start).Select(v => v.ToString()));\n        }\n\n        Console.WriteLine(string.Join(\", \", values));\n    }\n}"}
{"title": "Range expansion", "language": "C sharp 3.5+", "task": "{{:Range extraction/Format}}\n\n\n;Task:\nExpand the range description: \n   -6,-3--1,3-5,7-11,14,15,17-20 \nNote that the second element above, \nis the '''range from minus 3 to ''minus'' 1'''. \n\n\n;Related task:\n*   [[Range extraction]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace RangeExpansion {\n  internal static class StringExtensions {\n    internal static IEnumerable<int> ExpandRange(this string s) {\n      return s.Split(',')\n        .Select(rstr => {\n          int start;\n          if (int.TryParse(rstr, out start))\n            return new {Start = start, End = start};\n          var istr = new string((\"+-\".Any(_ => rstr[0] == _)\n            ? rstr.Take(1).Concat(rstr.Skip(1).TakeWhile(char.IsDigit))\n            : rstr.TakeWhile(char.IsDigit)\n            ).ToArray());\n          rstr = rstr.Substring(istr.Length + 1, (rstr.Length - istr.Length) - 1);\n          return new {Start = int.Parse(istr), End = int.Parse(rstr)};\n        }).SelectMany(_ => Enumerable.Range(_.Start, _.End - _.Start + 1));\n    }\n  }\n\n  internal static class Program {\n    private static void Main() {\n      const string RANGE_STRING = \"-6,-3--1,3-5,7-11,14,15,17-20\";\n      var values = RANGE_STRING.ExpandRange().ToList();\n      var vstr = string.Join(\", \", values.Select(_ => _.ToString()));\n      Console.WriteLine(vstr);\n    }\n  }\n}"}
{"title": "Range extraction", "language": "C sharp", "task": "{{:Range extraction/Format}}\n\n;Task:\n* Create a function that takes a list of integers in increasing order and returns a correctly formatted string in the range format. \n* Use the function to compute and print the range formatted version of the following ordered list of integers. (The correct answer is: 0-2,4,6-8,11,12,14-25,27-33,35-39).\n\n     0,  1,  2,  4,  6,  7,  8, 11, 12, 14,\n    15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n    25, 27, 28, 29, 30, 31, 32, 33, 35, 36,\n    37, 38, 39\n* Show the output of your program.\n\n\n;Related task:\n*   [[Range expansion]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nclass RangeExtraction\n{\n    static void Main()\n    {\n        const string testString = \"0,  1,  2,  4,  6,  7,  8, 11, 12, 14,15, 16, 17, 18, 19, 20, 21, 22, 23, 24,25, 27, 28, 29, 30, 31, 32, 33, 35, 36,37, 38, 39\";\n        var result = String.Join(\",\", RangesToStrings(GetRanges(testString)));\n        Console.Out.WriteLine(result);\n    }\n\n    public static IEnumerable<IEnumerable<int>> GetRanges(string testString)\n    {\n        var numbers = testString.Split(new[] { ',' }).Select(x => Convert.ToInt32(x));\n        var current = new List<int>();\n        foreach (var n in numbers)\n        {\n            if (current.Count == 0)\n            {\n                current.Add(n);\n            }\n            else\n            {\n                if (current.Max() + 1 == n)\n                {\n                    current.Add(n);\n                }\n                else\n                {\n                    yield return current;\n                    current = new List<int> { n };\n                }\n            }\n        }\n        yield return current;\n    }\n\n    public static IEnumerable<string> RangesToStrings(IEnumerable<IEnumerable<int>> ranges)\n    {\n        foreach (var range in ranges)\n        {\n            if (range.Count() == 1)\n            {\n                yield return range.Single().ToString();\n            }\n            else if (range.Count() == 2)\n            {\n                yield return range.Min() + \",\" + range.Max();\n            }\n            else\n            {\n                yield return range.Min() + \"-\" + range.Max();\n            }\n        }\n    }\n}\n"}
{"title": "Read a specific line from a file", "language": "C sharp", "task": "Some languages have special semantics for obtaining a known line number from a file.\n\n\n;Task:\nDemonstrate how to obtain the contents of a specific line within a file. \n\nFor the purpose of this task demonstrate how the contents of the seventh line of a file can be obtained,   and store it in a variable or in memory   (for potential future use within the program if the code were to become embedded). \n\nIf the file does not contain seven lines,   or the seventh line is empty,   or too big to be retrieved,   output an appropriate message. \n\nIf no special semantics are available for obtaining the required line,   it is permissible to read line by line. \n\nNote that empty lines are considered and should still be counted.\n\nAlso note that for functional languages or languages without variables or storage,   it is permissible to output the extracted data to standard output.\n\n", "solution": "using System;\nusing System.IO;\n\nnamespace GetLine\n{\n    internal class Program\n    {\n        private static void Main(string[] args)\n        {\n            Console.WriteLine(GetLine(args[0], uint.Parse(args[1])));\n        }\n\n        private static string GetLine(string path, uint line)\n        {\n            using (var reader = new StreamReader(path))\n            {\n                try\n                {\n                    for (uint i = 0; i <= line; i++)\n                    {\n                        if (reader.EndOfStream)\n                            return string.Format(\"There {1} less than {0} line{2} in the file.\", line,\n                                                 ((line == 1) ? \"is\" : \"are\"), ((line == 1) ? \"\" : \"s\"));\n\n                        if (i == line)\n                            return reader.ReadLine();\n\n                        reader.ReadLine();\n                    }\n                }\n                catch (IOException ex)\n                {\n                    return ex.Message;\n                }\n                catch (OutOfMemoryException ex)\n                {\n                    return ex.Message;\n                }\n            }\n\n            throw new Exception(\"Something bad happened.\");\n        }\n    }\n}"}
{"title": "Recaman's sequence", "language": "C sharp|C# from Kotlin", "task": "The '''Recaman's sequence''' generates Natural numbers.\n\nStarting from a(0)=0, the n'th term a(n), where n>0, is the previous term minus n i.e a(n) = a(n-1) - n but only if this is '''both''' positive ''and'' has not been previousely generated.\n\nIf the conditions ''don't'' hold then a(n) = a(n-1) + n.\n\n\n;Task:\n# Generate and show here the first 15 members of the sequence.\n# Find and show here, the first duplicated number in the sequence.\n# '''Optionally''': Find and show here, how many terms of the sequence are needed until all the integers 0..1000, inclusive, are generated.\n\n\n;References:\n* A005132,  The On-Line Encyclopedia of Integer Sequences.\n* The Slightly Spooky Recaman Sequence, Numberphile video.\n* Recaman's sequence, on Wikipedia.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace RecamanSequence {\n    class Program {\n        static void Main(string[] args) {\n            List<int> a = new List<int>() { 0 };\n            HashSet<int> used = new HashSet<int>() { 0 };\n            HashSet<int> used1000 = new HashSet<int>() { 0 };\n            bool foundDup = false;\n            int n = 1;\n            while (n <= 15 || !foundDup || used1000.Count < 1001) {\n                int next = a[n - 1] - n;\n                if (next < 1 || used.Contains(next)) {\n                    next += 2 * n;\n                }\n                bool alreadyUsed = used.Contains(next);\n                a.Add(next);\n                if (!alreadyUsed) {\n                    used.Add(next);\n                    if (0 <= next && next <= 1000) {\n                        used1000.Add(next);\n                    }\n                }\n                if (n == 14) {\n                    Console.WriteLine(\"The first 15 terms of the Recaman sequence are: [{0}]\", string.Join(\", \", a));\n                }\n                if (!foundDup && alreadyUsed) {\n                    Console.WriteLine(\"The first duplicated term is a[{0}] = {1}\", n, next);\n                    foundDup = true;\n                }\n                if (used1000.Count == 1001) {\n                    Console.WriteLine(\"Terms up to a[{0}] are needed to generate 0 to 1000\", n);\n                }\n                n++;\n            }\n        }\n    }\n}"}
{"title": "Remove lines from a file", "language": "C sharp 6", "task": "Remove a specific line or a number of lines from a file. \n\nThis should be implemented as a routine that takes three parameters (filename, starting line, and the number of lines to be removed). \n\nFor the purpose of this task, line numbers and the number of lines start at one, so to remove the first two lines from the file foobar.txt, the parameters should be: foobar.txt, 1, 2\n\nEmpty lines are considered and should still be counted, and if the specified line is empty, it should still be removed. \n\nAn appropriate message should appear if an attempt is made to remove lines beyond the end of the file.\n\n", "solution": "using System;\nusing System.IO;\nusing System.Linq;\n\npublic class Rosetta\n{\n    public static void Main() => RemoveLines(\"foobar.txt\", start: 1, count: 2);\n\n    static void RemoveLines(string filename, int start, int count = 1) =>\n        File.WriteAllLines(filename, File.ReadAllLines(filename)\n            .Where((line, index) => index < start - 1 || index >= start + count - 1));\n}"}
{"title": "Repeat", "language": "C sharp|C# from Java", "task": "Write a procedure which accepts as arguments another procedure and a positive integer. \n\nThe latter procedure is executed a number of times equal to the accepted integer.\n\n", "solution": "using System;\n\nnamespace Repeat {\n    class Program {\n        static void Repeat(int count, Action<int> fn) {\n            if (null == fn) {\n                throw new ArgumentNullException(\"fn\");\n            }\n            for (int i = 0; i < count; i++) {\n                fn.Invoke(i + 1);\n            }\n        }\n\n        static void Main(string[] args) {\n            Repeat(3, x => Console.WriteLine(\"Example {0}\", x));\n        }\n    }\n}"}
{"title": "Resistor mesh", "language": "C sharp|C# from Java", "task": "Given    10x10    grid nodes   (as shown in the image)   interconnected by    1O    resistors as shown,\nfind the resistance between points   '''A'''   and   '''B'''.\n\n\n;See also:\n*   (humor, nerd sniping)   xkcd.com cartoon (you can solve that for extra credits)\n*   An article on how to calculate this and an implementation in Mathematica\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace ResistorMesh {\n    class Node {\n        public Node(double v, int fixed_) {\n            V = v;\n            Fixed = fixed_;\n        }\n\n        public double V { get; set; }\n        public int Fixed { get; set; }\n    }\n\n    class Program {\n        static void SetBoundary(List<List<Node>> m) {\n            m[1][1].V = 1.0;\n            m[1][1].Fixed = 1;\n\n            m[6][7].V = -1.0;\n            m[6][7].Fixed = -1;\n        }\n\n        static double CalcuateDifference(List<List<Node>> m, List<List<Node>> d, int w, int h) {\n            double total = 0.0;\n            for (int i = 0; i < h; i++) {\n                for (int j = 0; j < w; j++) {\n                    double v = 0.0;\n                    int n = 0;\n                    if (i > 0) {\n                        v += m[i - 1][j].V;\n                        n++;\n                    }\n                    if (j > 0) {\n                        v += m[i][j - 1].V;\n                        n++;\n                    }\n                    if (i + 1 < h) {\n                        v += m[i + 1][j].V;\n                        n++;\n                    }\n                    if (j + 1 < w) {\n                        v += m[i][j + 1].V;\n                        n++;\n                    }\n                    v = m[i][j].V - v / n;\n                    d[i][j].V = v;\n                    if (m[i][j].Fixed == 0) {\n                        total += v * v;\n                    }\n                }\n            }\n            return total;\n        }\n\n        static double Iter(List<List<Node>> m, int w, int h) {\n            List<List<Node>> d = new List<List<Node>>(h);\n            for (int i = 0; i < h; i++) {\n                List<Node> t = new List<Node>(w);\n                for (int j = 0; j < w; j++) {\n                    t.Add(new Node(0.0, 0));\n                }\n                d.Add(t);\n            }\n\n            double[] curr = new double[3];\n            double diff = 1e10;\n\n            while (diff > 1e-24) {\n                SetBoundary(m);\n                diff = CalcuateDifference(m, d, w, h);\n                for (int i = 0; i < h; i++) {\n                    for (int j = 0; j < w; j++) {\n                        m[i][j].V -= d[i][j].V;\n                    }\n                }\n            }\n\n            for (int i = 0; i < h; i++) {\n                for (int j = 0; j < w; j++) {\n                    int k = 0;\n                    if (i != 0) k++;\n                    if (j != 0) k++;\n                    if (i < h - 1) k++;\n                    if (j < w - 1) k++;\n                    curr[m[i][j].Fixed + 1] += d[i][j].V * k;\n                }\n            }\n\n            return (curr[2] - curr[0]) / 2.0;\n        }\n\n        const int S = 10;\n        static void Main(string[] args) {\n            List<List<Node>> mesh = new List<List<Node>>(S);\n            for (int i = 0; i < S; i++) {\n                List<Node> t = new List<Node>(S);\n                for (int j = 0; j < S; j++) {\n                    t.Add(new Node(0.0, 0));\n                }\n                mesh.Add(t);\n            }\n\n            double r = 2.0 / Iter(mesh, S, S);\n            Console.WriteLine(\"R = {0:F15}\", r);\n        }\n    }\n}"}
{"title": "Reverse words in a string", "language": "C sharp|C#", "task": "Reverse the order of all tokens in each of a number of strings and display the result;   the order of characters within a token should not be modified.\n\n\n;Example:\nHey you, Bub!    would be shown reversed as:    Bub! you, Hey \n\n\nTokens are any non-space characters separated by spaces (formally, white-space);   the visible punctuation form part of the word within which it is located and should not be modified. \n\nYou may assume that there are no significant non-visible characters in the input.   Multiple or superfluous spaces may be compressed into a single space.\n\nSome strings have no tokens, so an empty string   (or one just containing spaces)   would be the result.\n\n'''Display''' the strings in order   (1st, 2nd, 3rd, ***),   and one string per line. \n\n(You can consider the ten strings as ten lines, and the tokens as words.)\n\n\n;Input data\n\n             (ten lines within the box)\n line\n     +----------------------------------------+\n   1 |  ---------- Ice and Fire ------------  |\n   2 |                                        |  <--- a blank line here.\n   3 |  fire, in end will world the say Some  |\n   4 |  ice. in say Some                      |\n   5 |  desire of tasted I've what From       |\n   6 |  fire. favor who those with hold I     |\n   7 |                                        |  <--- a blank line here.\n   8 |  ... elided paragraph last ...         |\n   9 |                                        |  <--- a blank line here.\n  10 |  Frost Robert -----------------------  |\n     +----------------------------------------+\n\n\n;Cf.\n* [[Phrase reversals]]\n\n", "solution": "using System;\n\npublic class ReverseWordsInString\n{\n    public static void Main(string[] args)\n    {\n        string text = @\"\n            ---------- Ice and Fire ------------\n\n            fire, in end will world the say Some\n            ice. in say Some\n            desire of tasted I've what From\n            fire. favor who those with hold I\n\n            ... elided paragraph last ...\n\n            Frost Robert -----------------------\n            \";\n\n        foreach (string line in text.Split(Environment.NewLine)) {\n            //Splits on any whitespace, not just spaces\n            string[] words = line.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries);\n            Array.Reverse(words);\n            WriteLine(string.Join(\" \", words));\n        }\n    }\n}"}
{"title": "Roman numerals/Decode", "language": "C sharp|C#", "task": "Create a function that takes a Roman numeral as its argument and returns its value as a numeric decimal integer. \n\nYou don't need to validate the form of the Roman numeral.\n\nModern Roman numerals are written by expressing each decimal digit of the number to be encoded separately, \nstarting with the leftmost decimal digit and skipping any '''0'''s   (zeroes). \n\n'''1990''' is rendered as   '''MCMXC'''     (1000 = M,   900 = CM,   90 = XC)     and \n'''2008''' is rendered as   '''MMVIII'''       (2000 = MM,   8 = VIII).\n \nThe Roman numeral for '''1666''',   '''MDCLXVI''',   uses each letter in descending order.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace Roman\n{\n    internal class Program\n    {\n        private static void Main(string[] args)\n        {\n            // Decode and print the numerals.\n            Console.WriteLine(\"{0}: {1}\", \"MCMXC\", Decode(\"MCMXC\"));\n            Console.WriteLine(\"{0}: {1}\", \"MMVIII\", Decode(\"MMVIII\"));\n            Console.WriteLine(\"{0}: {1}\", \"MDCLXVI\", Decode(\"MDCLXVI\"));\n        }\n\n        // Dictionary to hold our numerals and their values.\n        private static readonly Dictionary<char, int> RomanDictionary = new Dictionary<char, int>\n                                                                            {\n                                                                                {'I', 1},\n                                                                                {'V', 5},\n                                                                                {'X', 10},\n                                                                                {'L', 50},\n                                                                                {'C', 100},\n                                                                                {'D', 500},\n                                                                                {'M', 1000}\n                                                                            };\n\n        private static int Decode(string roman)\n        {\n            /* Make the input string upper-case,\n             * because the dictionary doesn't support lower-case characters. */\n            roman = roman.ToUpper();\n\n            /* total = the current total value that will be returned.\n             * minus = value to subtract from next numeral. */\n            int total = 0, minus = 0;\n\n            for (int i = 0; i < roman.Length; i++) // Iterate through characters.\n            {\n                // Get the value for the current numeral. Takes subtraction into account.\n                int thisNumeral = RomanDictionary[roman[i]] - minus;\n\n                /* Checks if this is the last character in the string, or if the current numeral\n                 * is greater than or equal to the next numeral. If so, we will reset our minus\n                 * variable and add the current numeral to the total value. Otherwise, we will\n                 * subtract the current numeral from the next numeral, and continue. */\n                if (i >= roman.Length - 1 ||\n                    thisNumeral + minus >= RomanDictionary[roman[i + 1]])\n                {\n                    total += thisNumeral;\n                    minus = 0;\n                }\n                else\n                {\n                    minus = thisNumeral;\n                }\n            }\n\n            return total; // Return the total.\n        }\n    }\n}"}
{"title": "Roman numerals/Encode", "language": "C sharp|C#", "task": "Create a function taking a positive integer as its parameter and returning a string containing the Roman numeral representation of that integer. Modern Roman numerals are written by expressing each digit separately, starting with the left most digit and skipping any digit with a value of zero. \n\n\nIn Roman numerals:\n* 1990  is rendered: 1000=M, 900=CM, 90=XC; resulting in MCMXC\n* 2008  is written as 2000=MM, 8=VIII; or MMVIII\n* 1666  uses each Roman symbol in descending order: MDCLXVI\n\n", "solution": "using System;\nclass Program\n{\n    static uint[] nums = { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 };\n    static string[] rum = { \"M\", \"CM\", \"D\", \"CD\", \"C\", \"XC\", \"L\", \"XL\", \"X\", \"IX\", \"V\", \"IV\", \"I\" };\n\n    static string ToRoman(uint number)\n    {\n        string value = \"\";\n        for (int i = 0; i < nums.Length && number != 0; i++)\n        {\n            while (number >= nums[i])\n            {\n                number -= nums[i];\n                value += rum[i];\n            }\n        }\n        return value;\n    }\n\n    static void Main()\n    {\n        for (uint number = 1; number <= 1 << 10; number *= 2)\n        {\n            Console.WriteLine(\"{0} = {1}\", number, ToRoman(number));\n        }\n    }\n}"}
{"title": "Runge-Kutta method", "language": "C sharp|C#", "task": "Given the example Differential equation:\n:y'(t) = t \\times \\sqrt {y(t)}\nWith initial condition:\n:t_0 = 0 and y_0 = y(t_0) = y(0) = 1\nThis equation has an exact solution:\n:y(t) = \\tfrac{1}{16}(t^2 +4)^2\n\n\n;Task\nDemonstrate the commonly used explicit   fourth-order Runge-Kutta method   to solve the above differential equation.\n* Solve the given differential equation over the range t = 0 \\ldots 10 with a step value of \\delta t=0.1 (101 total points, the first being given)\n* Print the calculated values of y at whole numbered t's (0.0, 1.0, \\ldots 10.0) along with error as compared to the exact solution.\n\n\n;Method summary\nStarting with a given y_n and t_n calculate:\n:\\delta y_1 = \\delta t\\times y'(t_n, y_n)\\quad\n:\\delta y_2 = \\delta t\\times y'(t_n + \\tfrac{1}{2}\\delta t , y_n + \\tfrac{1}{2}\\delta y_1)\n:\\delta y_3 = \\delta t\\times y'(t_n + \\tfrac{1}{2}\\delta t , y_n + \\tfrac{1}{2}\\delta y_2)\n:\\delta y_4 = \\delta t\\times y'(t_n + \\delta t , y_n + \\delta y_3)\\quad\nthen:\n:y_{n+1} = y_n + \\tfrac{1}{6} (\\delta y_1 + 2\\delta y_2 + 2\\delta y_3 + \\delta y_4)\n:t_{n+1} = t_n + \\delta t\\quad\n\n", "solution": "using System;\n\nnamespace RungeKutta\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            //Incrementers to pass into the known solution\n            double t = 0.0;\n            double T = 10.0;\n            double dt = 0.1;\n\n            // Assign the number of elements needed for the arrays\n            int n = (int)(((T - t) / dt)) + 1;\n\n            // Initialize the arrays for the time index 's' and estimates 'y' at each index 'i'\n            double[] y = new double[n];\n            double[] s = new double[n];\n\n            // RK4 Variables\n            double dy1;\n            double dy2;\n            double dy3;\n            double dy4;\n\n            // RK4 Initializations\n            int i = 0;\n            s[i] = 0.0;\n            y[i] = 1.0;\n\n            Console.WriteLine(\" ===================================== \");\n            Console.WriteLine(\" Beging 4th Order Runge Kutta Method \");\n            Console.WriteLine(\" ===================================== \");\n\n            Console.WriteLine();\n            Console.WriteLine(\" Given the example Differential equation: \\n\");\n            Console.WriteLine(\"     y' = t*sqrt(y) \\n\");\n            Console.WriteLine(\" With the initial conditions: \\n\");\n            Console.WriteLine(\"     t0 = 0\" + \", y(0) = 1.0 \\n\");\n            Console.WriteLine(\" Whose exact solution is known to be: \\n\");\n            Console.WriteLine(\"     y(t) = 1/16*(t^2 + 4)^2 \\n\");\n            Console.WriteLine(\" Solve the given equations over the range t = 0...10 with a step value dt = 0.1 \\n\");\n            Console.WriteLine(\" Print the calculated values of y at whole numbered t's (0.0,1.0,...10.0) along with the error \\n\");\n            Console.WriteLine();\n\n            Console.WriteLine(\" y(t) \" +\"RK4\" + \" \".PadRight(18) + \"Absolute Error\");\n            Console.WriteLine(\" -------------------------------------------------\");\n            Console.WriteLine(\" y(0) \" + y[i] + \" \".PadRight(20) + (y[i] - solution(s[i])));\n\n            // Iterate and implement the Rk4 Algorithm\n            while (i < y.Length - 1)\n            {\n\n                dy1 = dt * equation(s[i], y[i]);\n                dy2 = dt * equation(s[i] + dt / 2, y[i] + dy1 / 2);\n                dy3 = dt * equation(s[i] + dt / 2, y[i] + dy2 / 2);\n                dy4 = dt * equation(s[i] + dt, y[i] + dy3);\n\n                s[i + 1] = s[i] + dt;\n                y[i + 1] = y[i] + (dy1 + 2 * dy2 + 2 * dy3 + dy4) / 6;\n\n                double error = Math.Abs(y[i + 1] - solution(s[i + 1]));\n                double t_rounded = Math.Round(t + dt, 2);\n\n                if (t_rounded % 1 == 0)\n                {\n                    Console.WriteLine(\" y(\" + t_rounded + \")\" + \" \" + y[i + 1] + \" \".PadRight(5) + (error));\n                }\n\n                i++;\n                t += dt;\n\n            };//End Rk4\n\n            Console.ReadLine();\n        }\n\n        // Differential Equation\n        public static double equation(double t, double y)\n        {\n            double y_prime;\n            return y_prime = t*Math.Sqrt(y);\n        }\n\n        // Exact Solution\n        public static double solution(double t)\n        {\n            double actual;\n            actual = Math.Pow((Math.Pow(t, 2) + 4), 2)/16;\n            return actual;\n        }\n    }\n}"}
{"title": "SHA-1", "language": "C sharp", "task": "'''SHA-1''' or '''SHA1''' is a one-way hash function; \nit computes a 160-bit message digest. \nSHA-1 often appears in security protocols; for example, \nmany HTTPS websites use RSA with SHA-1 to secure their connections. \nBitTorrent uses SHA-1 to verify downloads. \nGit and Mercurial use SHA-1 digests to identify commits.\n\nA US government standard, FIPS 180-1, defines SHA-1.\n\nFind the SHA-1 message digest for a string of [[octet]]s. You may either call a SHA-1 library, or implement SHA-1 in your language. Both approaches interest Rosetta Code.\n\n{{alertbox|lightgray|'''Warning:''' SHA-1 has known weaknesses. Theoretical attacks may find a collision after 252 operations, or perhaps fewer. \nThis is much faster than a brute force attack of 280 operations. USgovernment deprecated SHA-1. \nFor production-grade cryptography, users may consider a stronger alternative, such as SHA-256 (from the SHA-2 family) or the upcoming SHA-3.}}\n", "solution": "using System;\nusing System.Security.Cryptography;\nusing System.Text;\nusing Microsoft.VisualStudio.TestTools.UnitTesting;\n\nnamespace RosettaCode.SHA1\n{\n    [TestClass]\n    public class SHA1CryptoServiceProviderTest\n    {\n        [TestMethod]\n        public void TestComputeHash()\n        {\n            var input = new UTF8Encoding().GetBytes(\"Rosetta Code\");\n            var output = new SHA1CryptoServiceProvider().ComputeHash(input);\n            Assert.AreEqual(\n                \"48-C9-8F-7E-5A-6E-73-6D-79-0A-B7-40-DF-C3-F5-1A-61-AB-E2-B5\",\n                BitConverter.ToString(output));\n        }\n    }\n}"}
{"title": "Sailors, coconuts and a monkey problem", "language": "C sharp|C# from Java", "task": "Five sailors are shipwrecked on an island and collect a large pile of coconuts during the day. \n\nThat night the first sailor wakes up and decides to take his first share early  so tries to divide the pile of coconuts equally into five piles but finds that there is one coconut left over, so he tosses it to a monkey and then hides \"his\" one of the five equally sized piles of coconuts and pushes the other four piles together to form a single visible pile of coconuts again and goes to bed.\n\nTo cut a long story short, each of the sailors in turn gets up once during the night and performs the same actions of dividing the coconut pile into five, finding that one coconut is left over and giving that single remainder coconut to the monkey.\n\nIn the morning (after the surreptitious and separate action of each of the five sailors during the night), the remaining coconuts are divided into five equal piles for each of the sailors, whereupon it is found that the pile of coconuts divides equally amongst the sailors with no remainder. (Nothing for the monkey in the morning.)\n\n\n;The task:\n# Calculate the minimum possible size of the initial pile of coconuts collected during the first day.\n# Use a method that assumes an answer is possible, and then applies the constraints of the tale to see if it is correct. (I.e. no applying some formula that generates the correct answer without integer divisions and remainders and tests on remainders; but constraint solvers ''are'' allowed.)\n# Calculate the size of the initial pile of coconuts if six sailors were marooned and went through a similar process (but split into six piles instead of five of course).\n# Show your answers here.\n\n\n;Extra credit (optional):\n* Give some indication of the number of coconuts each sailor hides during the night.\n\n\n;Note:\n* Of course the tale is told in a world where the collection of any amount of coconuts in a day and multiple divisions of the pile, etc can occur in time fitting the story line, so as not to affect the mathematics.\n* The tale is also told in a version where the monkey also gets a coconut in the morning. This is ''not'' that tale!\n\n\n;C.f:\n* Monkeys and Coconuts - Numberphile (Video) Analytical solution.\n* A002021: Pile of coconuts problem The On-Line Encyclopedia of Integer Sequences. (Although some of its references may use the alternate form of the tale).\n\n", "solution": "class Test\n{\n    static bool valid(int n, int nuts)\n    {\n        for (int k = n; k != 0; k--, nuts -= 1 + nuts / n)\n        {\n            if (nuts % n != 1)\n            {\n                return false;\n            }                \n        }\n            \n        return nuts != 0 && (nuts % n == 0);\n    }\n\n    static void Main(string[] args)\n    {\n        int x = 0;\n        for (int n = 2; n < 10; n++)\n        {\n            while (!valid(n, x))\n                x++;\n            System.Console.WriteLine(n + \": \" + x);\n        }\n    }\n}"}
{"title": "Same fringe", "language": "c sharp|C#", "task": "Write a routine that will compare the leaves (\"fringe\") of two binary trees to determine whether they are the same list of leaves when visited left-to-right.  The structure or balance of the trees does not matter; only the number, order, and value of the leaves is important.\n\nAny solution is allowed here, but many computer scientists will consider it inelegant to collect either fringe in its entirety before starting to collect the other one.  In fact, this problem is usually proposed in various forums as a way to show off various forms of concurrency (tree-rotation algorithms have also been used to get around the need to collect one tree first).  Thinking of it a slightly different way, an elegant solution is one that can perform the minimum amount of work to falsify the equivalence of the fringes when they differ somewhere in the middle, short-circuiting the unnecessary additional traversals and comparisons.\n\nAny representation of a binary tree is allowed, as long as the nodes are orderable, and only downward links are used (for example, you may not use parent or sibling pointers to avoid recursion).\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Same_Fringe\n{\n\tclass Program\n\t{\n\t\tstatic void Main()\n\t\t{\n\t\t\tvar rnd = new Random(110456);\n\t\t\tvar randList = Enumerable.Range(0, 20).Select(i => rnd.Next(1000)).ToList();\n\t\t\tvar bt1 = new BinTree<int>(randList);\n\t\t\t// Shuffling will create a tree with the same values but different topology\n\t\t\tShuffle(randList, 428);\n\t\t\tvar bt2 = new BinTree<int>(randList);\n\t\t\tConsole.WriteLine(bt1.CompareTo(bt2) ? \"True compare worked\" : \"True compare failed\");\n\t\t\t// Insert a 0 in the first tree which should cause a failure\n\t\t\tbt1.Insert(0);\n\t\t\tConsole.WriteLine(bt1.CompareTo(bt2) ? \"False compare failed\" : \"False compare worked\");\n\t\t}\n\n\t\tstatic void Shuffle<T>(List<T> values, int seed)\n\t\t{\n\t\t\tvar rnd = new Random(seed);\n\n\t\t\tfor (var i = 0; i < values.Count - 2; i++)\n\t\t\t{\n\t\t\t\tvar iSwap = rnd.Next(values.Count - i) + i;\n\t\t\t\tvar tmp = values[iSwap];\n\t\t\t\tvalues[iSwap] = values[i];\n\t\t\t\tvalues[i] = tmp;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Define other methods and classes here\n\tclass BinTree<T> where T:IComparable\n\t{\n\t\tprivate BinTree<T> _left;\n\t\tprivate BinTree<T> _right;\n\t\tprivate T _value;\n\n\t\tprivate BinTree<T> Left\n\t\t{\n\t\t\tget { return _left; }\n\t\t}\n\n\t\tprivate BinTree<T> Right\n\t\t{\n\t\t\tget { return _right; }\n\t\t}\n\n\t\t// On interior nodes, any value greater than or equal to Value goes in the\n\t\t// right subtree, everything else in the left.\n\t\tprivate T Value\n\t\t{\n\t\t\tget { return _value; }\n\t\t}\n\n\t\tpublic bool IsLeaf { get { return Left == null; } }\n\n\t\tprivate BinTree(BinTree<T> left, BinTree<T> right, T value)\n\t\t{\n\t\t\t_left = left;\n\t\t\t_right = right;\n\t\t\t_value = value;\n\t\t}\n\n\t\tpublic BinTree(T value) : this(null, null, value) { }\n\n\t\tpublic BinTree(IEnumerable<T> values)\n\t\t{\n\t\t\t// ReSharper disable PossibleMultipleEnumeration\n\t\t\t_value = values.First();\n\t\t\tforeach (var value in values.Skip(1))\n\t\t\t{\n\t\t\t\tInsert(value);\n\t\t\t}\n\t\t\t// ReSharper restore PossibleMultipleEnumeration\n\t\t}\n\n\t\tpublic void Insert(T value)\n\t\t{\n\t\t\tif (IsLeaf)\n\t\t\t{\n\t\t\t\tif (value.CompareTo(Value) < 0)\n\t\t\t\t{\n\t\t\t\t\t_left = new BinTree<T>(value);\n\t\t\t\t\t_right = new BinTree<T>(Value);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t_left = new BinTree<T>(Value);\n\t\t\t\t\t_right = new BinTree<T>(value);\n\t\t\t\t\t_value = value;\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tif (value.CompareTo(Value) < 0)\n\t\t\t\t{\n\t\t\t\t\tLeft.Insert(value);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tRight.Insert(value);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tpublic IEnumerable<T> GetLeaves()\n\t\t{\n\t\t\tif (IsLeaf)\n\t\t\t{\n\t\t\t\tyield return Value;\n\t\t\t\tyield break;\n\t\t\t}\n\t\t\tforeach (var val in Left.GetLeaves())\n\t\t\t{\n\t\t\t\tyield return val;\n\t\t\t}\n\t\t\tforeach (var val in Right.GetLeaves())\n\t\t\t{\n\t\t\t\tyield return val;\n\t\t\t}\n\t\t}\n\n\t\tinternal bool CompareTo(BinTree<T> other)\n\t\t{\n\t\t\treturn other.GetLeaves().Zip(GetLeaves(), (t1, t2) => t1.CompareTo(t2) == 0).All(f => f);\n\t\t}\n\t}\n}\n"}
{"title": "Self numbers", "language": "C#|CSharp from Pascal", "task": "A number n is a self number if there is no number g such that g + the sum of g's digits = n. So 18 is not a self number because 9+9=18, 43 is not a self number because 35+5+3=43.\n\nThe task is:\n  Display the first 50 self numbers;\n  I believe that the 100000000th self number is 1022727208. You should either confirm or dispute my conjecture.\n\n224036583-1 is a Mersenne prime, claimed to also be a self number. Extra credit to anyone proving it.\n\n;See also: \n\n;*OEIS: A003052 - Self numbers or Colombian numbers\n;*Wikipedia: Self numbers\n\n", "solution": "using System;\nusing static System.Console;\n\nclass Program {\n\n  const int mc = 103 * 1000 * 10000 + 11 * 9 + 1;\n\n  static bool[] sv = new bool[mc + 1];\n\n  static void sieve() { int[] dS = new int[10000];\n    for (int a = 9, i = 9999; a >= 0; a--)\n      for (int b = 9; b >= 0; b--)\n        for (int c = 9, s = a + b; c >= 0; c--)\n          for (int d = 9, t = s + c; d >= 0; d--)\n            dS[i--] = t + d;\n    for (int a = 0, n = 0; a < 103; a++)\n      for (int b = 0, d = dS[a]; b < 1000; b++, n += 10000)\n        for (int c = 0, s = d + dS[b] + n; c < 10000; c++)\n          sv[dS[c] + s++] = true; }\n\n  static void Main() { DateTime st = DateTime.Now; sieve();\n    WriteLine(\"Sieving took {0}s\", (DateTime.Now - st).TotalSeconds); \n    WriteLine(\"\\nThe first 50 self numbers are:\");\n    for (int i = 0, count = 0; count <= 50; i++) if (!sv[i]) {\n        count++; if (count <= 50) Write(\"{0} \", i);\n        else WriteLine(\"\\n\\n       Index     Self number\"); }\n    for (int i = 0, limit = 1, count = 0; i < mc; i++)\n      if (!sv[i]) if (++count == limit) {\n          WriteLine(\"{0,12:n0} \u00a0 {1,13:n0}\", count, i);\n          if (limit == 1e9) break; limit *= 10; }\n    WriteLine(\"\\nOverall took {0}s\", (DateTime.Now - st). TotalSeconds);\n  }\n}"}
{"title": "Semordnilap", "language": "C sharp", "task": "A semordnilap is a word (or phrase) that spells a different word (or phrase) backward. \"Semordnilap\" is a word that itself is a semordnilap.\n\nExample: ''lager'' and ''regal''\n \n;Task\nThis task does not consider semordnilap phrases, only single words.\nUsing only words from this list, report the total number of unique semordnilap pairs, and print 5 examples.\nTwo matching semordnilaps, such as ''lager'' and ''regal'', should be counted as one unique pair.\n(Note that the word \"semordnilap\" is not in the above dictionary.)\n\n\n\n", "solution": "using System;\nusing System.Net;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.IO;\n\npublic class Semordnilap\n{\n    public static void Main() {\n        var results = FindSemordnilaps(\"http://www.puzzlers.org/pub/wordlists/unixdict.txt\").ToList();\n        Console.WriteLine(results.Count);\n        var random = new Random();\n        Console.WriteLine(\"5 random results:\");\n        foreach (string s in results.OrderBy(_ => random.Next()).Distinct().Take(5)) Console.WriteLine(s + \" \" + Reversed(s));\n    }\n    \n    private static IEnumerable<string> FindSemordnilaps(string url) {\n        var found = new HashSet<string>();\n        foreach (string line in GetLines(url)) {\n            string reversed = Reversed(line);\n            //Not taking advantage of the fact the input file is sorted\n            if (line.CompareTo(reversed) != 0) {\n                if (found.Remove(reversed)) yield return reversed;\n                else found.Add(line);\n            }\n        }\n    }\n    \n    private static IEnumerable<string> GetLines(string url) {\n        WebRequest request = WebRequest.Create(url);\n        using (var reader = new StreamReader(request.GetResponse().GetResponseStream(), true)) {\n            while (!reader.EndOfStream) {\n                yield return reader.ReadLine();\n            }\n        }\n    }\n    \n    private static string Reversed(string value) => new string(value.Reverse().ToArray());\n}"}
{"title": "Set consolidation", "language": "C sharp", "task": "Given two sets of items then if any item is common to any set then the result of applying ''consolidation'' to those sets is a set of sets whose contents is:\n*  The two input sets if no common item exists between the two input sets of items.\n*  The single set that is the union of the two input sets if they share a common item.\n\nGiven N sets of items where N>2 then the result is the same as repeatedly replacing all combinations of two sets by their consolidation until no further consolidation between set pairs is possible.\nIf N<2 then consolidation has no strict meaning and the input can be returned.\n\n;'''Example 1:'''\n:Given the two sets {A,B} and {C,D} then there is no common element between the sets and the result is the same as the input.\n;'''Example 2:'''\n:Given the two sets {A,B} and {B,D} then there is a common element B between the sets and the result is the single set {B,D,A}.  (Note that order of items in a set is immaterial: {A,B,D} is the same as {B,D,A} and {D,A,B}, etc).\n;'''Example 3:'''\n:Given the three sets {A,B} and {C,D} and {D,B} then there is no common element between the sets {A,B} and {C,D} but the sets {A,B} and {D,B} do share a common element that consolidates to produce the result {B,D,A}. On examining this result with the remaining set, {C,D}, they share a common element and so consolidate to the final output of the single set {A,B,C,D}\n;'''Example 4:'''\n:The consolidation of the five sets:\n::{H,I,K}, {A,B}, {C,D}, {D,B}, and {F,G,H}\n:Is the two sets:\n::{A, C, B, D}, and {G, F, I, H, K}\n\n'''See also'''\n* Connected component (graph theory)\n* [[Range consolidation]]\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\npublic class SetConsolidation\n{\n    public static void Main()\n    {\n        var setCollection1 = new[] {new[] {\"A\", \"B\"}, new[] {\"C\", \"D\"}};\n        var setCollection2 = new[] {new[] {\"A\", \"B\"}, new[] {\"B\", \"D\"}};\n        var setCollection3 = new[] {new[] {\"A\", \"B\"}, new[] {\"C\", \"D\"}, new[] {\"B\", \"D\"}};\n        var setCollection4 = new[] {new[] {\"H\", \"I\", \"K\"}, new[] {\"A\", \"B\"}, new[] {\"C\", \"D\"},\n            new[] {\"D\", \"B\"}, new[] {\"F\", \"G\", \"H\"}};\n        var input = new[] {setCollection1, setCollection2, setCollection3, setCollection4};\n        \n        foreach (var sets in input) {\n            Console.WriteLine(\"Start sets:\");\n            Console.WriteLine(string.Join(\", \", sets.Select(s => \"{\" + string.Join(\", \", s) + \"}\")));\n            Console.WriteLine(\"Sets consolidated using Nodes:\");\n            Console.WriteLine(string.Join(\", \", ConsolidateSets1(sets).Select(s => \"{\" + string.Join(\", \", s) + \"}\")));\n            Console.WriteLine(\"Sets consolidated using Set operations:\");\n            Console.WriteLine(string.Join(\", \", ConsolidateSets2(sets).Select(s => \"{\" + string.Join(\", \", s) + \"}\")));\n            Console.WriteLine();\n        }\n    }\n    \n    /// <summary>\n    /// Consolidates sets using a connected-component-finding-algorithm involving Nodes with parent pointers.\n    /// The more efficient solution, but more elaborate code.\n    /// </summary>\n    private static IEnumerable<IEnumerable<T>> ConsolidateSets1<T>(IEnumerable<IEnumerable<T>> sets,\n        IEqualityComparer<T> comparer = null)\n    {\n        if (comparer == null) comparer = EqualityComparer<T>.Default;\n        var elements = new Dictionary<T, Node<T>>();\n        foreach (var set in sets) {\n            Node<T> top = null;\n            foreach (T value in set) {\n                Node<T> element;\n                if (elements.TryGetValue(value, out element)) {\n                    if (top != null) {\n                        var newTop = element.FindTop();\n                        top.Parent = newTop;\n                        element.Parent = newTop;\n                        top = newTop;\n                    } else {\n                        top = element.FindTop();\n                    }\n                } else {\n                    elements.Add(value, element = new Node<T>(value));\n                    if (top == null) top = element;\n                    else element.Parent = top;\n                }\n            }\n        }\n        foreach (var g in elements.Values.GroupBy(element => element.FindTop().Value))\n            yield return g.Select(e => e.Value);\n    }\n    \n    private class Node<T>\n    {\n        public Node(T value, Node<T> parent = null) {\n            Value = value;\n            Parent = parent ?? this;\n        }\n        \n        public T Value { get; }\n        public Node<T> Parent { get; set; }\n        \n        public Node<T> FindTop() {\n            var top = this;\n            while (top != top.Parent) top = top.Parent;\n            //Set all parents to the top element to prevent repeated iteration in the future\n            var element = this;\n            while (element.Parent != top) {\n                var parent = element.Parent;\n                element.Parent = top;\n                element = parent;\n            }\n            return top;\n        }\n    }\n    \n    /// <summary>\n    /// Consolidates sets using operations on the HashSet&lt;T&gt; class.\n    /// Less efficient than the other method, but easier to write.\n    /// </summary>\n    private static IEnumerable<IEnumerable<T>> ConsolidateSets2<T>(IEnumerable<IEnumerable<T>> sets,\n        IEqualityComparer<T> comparer = null)\n    {\n        if (comparer == null) comparer = EqualityComparer<T>.Default;\n        var currentSets = sets.Select(s => new HashSet<T>(s)).ToList();\n        int previousSize;\n        do {\n            previousSize = currentSets.Count;\n            for (int i = 0; i < currentSets.Count - 1; i++) {\n                for (int j = currentSets.Count - 1; j > i; j--) {\n                    if (currentSets[i].Overlaps(currentSets[j])) {\n                        currentSets[i].UnionWith(currentSets[j]);\n                        currentSets.RemoveAt(j);\n                    }\n                }\n            }\n        } while (previousSize > currentSets.Count);\n        foreach (var set in currentSets) yield return set.Select(value => value);\n    }\n}"}
{"title": "Set of real numbers", "language": "C sharp", "task": "All real numbers form the uncountable set R.  Among its subsets, relatively simple are the convex sets, each expressed as a range between two real numbers ''a'' and ''b'' where ''a'' <= ''b''.  There are actually four cases for the meaning of \"between\", depending on open or closed boundary:\n* [''a'', ''b'']: {''x'' | ''a'' <= ''x'' and ''x'' <= ''b'' }\n* (''a'', ''b''): {''x'' | ''a'' < ''x'' and ''x'' < ''b'' }\n* [''a'', ''b''): {''x'' | ''a'' <= ''x'' and ''x'' < ''b'' }\n* (''a'', ''b'']: {''x'' | ''a'' < ''x'' and ''x'' <= ''b'' }\nNote that if ''a'' = ''b'', of the four only [''a'', ''a''] would be non-empty.\n\n'''Task'''\n* Devise a way to represent any set of real numbers, for the definition of 'any' in the implementation notes below.\n* Provide methods for these common set operations (''x'' is a real number; ''A'' and ''B'' are sets):\n:* ''x''  ''A'': determine if ''x'' is an element of ''A''\n:: example: 1 is in [1, 2), while 2, 3, ... are not.\n:* ''A''  ''B'': union of ''A'' and ''B'', i.e. {''x'' | ''x''  ''A'' or ''x''  ''B''}\n:: example: [0, 2)  (1, 3) = [0, 3); [0, 1)  (2, 3] = well, [0, 1)  (2, 3]\n:* ''A''  ''B'': intersection of ''A'' and ''B'', i.e. {''x'' | ''x''  ''A'' and ''x''  ''B''}\n:: example: [0, 2)  (1, 3) = (1, 2); [0, 1)  (2, 3] = empty set\n:* ''A'' - ''B'': difference between ''A'' and ''B'', also written as ''A'' \\ ''B'', i.e. {''x'' | ''x''  ''A'' and ''x''  ''B''}\n:: example: [0, 2) - (1, 3) = [0, 1]\n* Test your implementation by checking if numbers 0, 1, and 2 are in any of the following sets:\n:* (0, 1]  [0, 2)\n:* [0, 2)  (1, 2]\n:* [0, 3) - (0, 1)\n:* [0, 3) - [0, 1]\n\n'''Implementation notes'''\n* 'Any' real set means 'sets that can be expressed as the union of a finite number of convex real sets'.  Cantor's set needs not apply.\n* Infinities should be handled gracefully; indeterminate numbers (NaN) can be ignored.\n* You can use your machine's native real number representation, which is probably IEEE floating point, and assume it's good enough (it usually is).\n\n'''Optional work'''\n* Create a function to determine if a given set is empty (contains no element).\n* Define ''A'' = {''x'' | 0 < ''x'' < 10 and |sin(p ''x''2)| > 1/2 }, ''B'' = {''x'' | 0 < ''x'' < 10 and |sin(p ''x'')| > 1/2}, calculate the length of the real axis covered by the set ''A'' - ''B''.  Note that \n|sin(p ''x'')| > 1/2 is the same as ''n'' + 1/6 < ''x'' < ''n'' + 5/6 for all integers ''n''; your program does not need to derive this by itself.\n\n", "solution": "using Microsoft.VisualStudio.TestTools.UnitTesting;\nusing RosettaCode.SetOfRealNumbers;\n\nnamespace RosettaCode.SetOfRealNumbersTest\n{\n    [TestClass]\n    public class SetTest\n    {\n        [TestMethod]\n        public void TestUnion()\n        {\n            var set =\n                new Set<double>(value => 0d < value && value <= 1d).Union(\n                    new Set<double>(value => 0d <= value && value < 2d));\n            Assert.IsTrue(set.Contains(0d));\n            Assert.IsTrue(set.Contains(1d));\n            Assert.IsFalse(set.Contains(2d));\n        }\n\n        [TestMethod]\n        public void TestIntersection()\n        {\n            var set =\n                new Set<double>(value => 0d <= value && value < 2d).Intersection(\n                    new Set<double>(value => 1d < value && value <= 2d));\n            Assert.IsFalse(set.Contains(0d));\n            Assert.IsFalse(set.Contains(1d));\n            Assert.IsFalse(set.Contains(2d));\n        }\n\n        [TestMethod]\n        public void TestDifference()\n        {\n            var set =\n                new Set<double>(value => 0d <= value && value < 3d).Difference(\n                    new Set<double>(value => 0d < value && value < 1d));\n            Assert.IsTrue(set.Contains(0d));\n            Assert.IsTrue(set.Contains(1d));\n            Assert.IsTrue(set.Contains(2d));\n\n            set =\n                new Set<double>(value => 0d <= value && value < 3d).Difference(\n                    new Set<double>(value => 0d <= value && value <= 1d));\n            Assert.IsFalse(set.Contains(0d));\n            Assert.IsFalse(set.Contains(1d));\n            Assert.IsTrue(set.Contains(2d));\n        }\n    }\n}"}
{"title": "Shoelace formula for polygonal area", "language": "C sharp|C# from Java", "task": "Given the n + 1 vertices x[0], y[0] .. x[N], y[N] of a simple polygon described in a clockwise direction, then the polygon's area can be calculated by:\n\nabs( (sum(x[0]*y[1] + ... x[n-1]*y[n]) + x[N]*y[0]) -\n     (sum(x[1]*y[0] + ... x[n]*y[n-1]) + x[0]*y[N])\n   ) / 2\n(Where abs returns the absolute value)\n\n;Task:\nWrite a function/method/routine to use the the Shoelace formula to calculate the area of the polygon described by the ordered points:\n      (3,4), (5,11), (12,8), (9,5), and (5,6) \n\n\nShow the answer here, on this page.\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace ShoelaceFormula {\n    using Point = Tuple<double, double>;\n\n    class Program {\n        static double ShoelaceArea(List<Point> v) {\n            int n = v.Count;\n            double a = 0.0;\n            for (int i = 0; i < n - 1; i++) {\n                a += v[i].Item1 * v[i + 1].Item2 - v[i + 1].Item1 * v[i].Item2;\n            }\n            return Math.Abs(a + v[n - 1].Item1 * v[0].Item2 - v[0].Item1 * v[n - 1].Item2) / 2.0;\n        }\n\n        static void Main(string[] args) {\n            List<Point> v = new List<Point>() {\n                new Point(3,4),\n                new Point(5,11),\n                new Point(12,8),\n                new Point(9,5),\n                new Point(5,6),\n            };\n            double area = ShoelaceArea(v);\n            Console.WriteLine(\"Given a polygon with vertices [{0}],\", string.Join(\", \", v));\n            Console.WriteLine(\"its area is {0}.\", area);\n        }\n    }\n}"}
{"title": "Shortest common supersequence", "language": "C sharp from Java", "task": "The   '''shortest common supersequence'''   is a problem closely related to the   [[longest common subsequence]],   which you can use as an external function for this task.\n\n\n;;Task:\nGiven two strings u and v, find the shortest possible sequence s, which is the shortest common super-sequence of u and v where both u and v are a subsequence of s.  Defined as such, s is not necessarily unique.\n\nDemonstrate this by printing s where u = \"abcbdab\" and v = \"bdcaba\".\n\n\n\n;Also see:\n* Wikipedia: shortest common supersequence \n\n", "solution": "public class ShortestCommonSupersequence\n{\n    Dictionary<(string, string), string> cache = new();\n\n    public string scs(string x, string y)\n    {\n        if (x.Length == 0) return y;\n        if (y.Length == 0) return x;\n\n        if (cache.TryGetValue((x, y), out var result)) return result;\n\n        if (x[0] == y[0])\n        {\n            return cache[(x, y)] = x[0] + scs(x.Substring(1), y.Substring(1));\n        }\n\n        var xr = scs(x.Substring(1), y);\n        var yr = scs(x, y.Substring(1));\n        if (yr.Length <= xr.Length)\n        {\n            return cache[(x, y)] = y[0] + yr;\n        }\n        else\n        {\n            return cache[(x, y)] = x[0] + xr;\n        }\n    }\n\n    public static void Main(string[] args)\n    {\n        var scs = new ShortestCommonSupersequence();\n        Console.WriteLine(scs.scs(\"abcbdab\", \"bdcaba\"));\n    }\n}\n"}
{"title": "Show ASCII table", "language": "C sharp", "task": "Show  the ASCII character set  from values   '''32'''   to   '''127'''   (decimal)   in a table format.\n\n\n\n", "solution": "using static System.Console;\nusing static System.Linq.Enumerable;\n\npublic class Program\n{\n    static void Main()\n    {\n        for (int start = 32; start + 16 * 5 < 128; start++) {\n            WriteLine(string.Concat(Range(0, 6).Select(i => $\"{start+16*i, 3} : {Text(start+16*i), -6}\")));\n        }\n\n        string Text(int index) => index == 32 ? \"Sp\" : index == 127 ? \"Del\" : (char)index + \"\";\n    }\n}"}
{"title": "Show the epoch", "language": "C sharp|C#", "task": "Choose popular date libraries used by your language and show the   epoch   those libraries use. \n\nA demonstration is preferable   (e.g. setting the internal representation of the date to 0 ms/ns/etc.,   or another way that will still show the epoch even if it is changed behind the scenes by the implementers),   but text from (with links to) documentation is also acceptable where a demonstration is impossible/impractical. \n\nFor consistency's sake, show the date in UTC time where possible.\n\n\n;Related task:\n*   [[Date format]]\n\n", "solution": "using System;\n\nclass Program\n{\n    static void Main()\n    {\n        Console.WriteLine(new DateTime());\n    }\n}"}
{"title": "Smith numbers", "language": "C sharp|C# from java", "task": "sum of the decimal digits of the integers that make up that number is the same as the sum of the decimal digits of its prime factors excluding 1. \n\nBy definition, all primes are ''excluded'' as they (naturally) satisfy this condition!\n\nSmith numbers are also known as   ''joke''   numbers.\n\n\n;Example\nUsing the number '''166'''\nFind the prime factors of '''166''' which are: '''2''' x '''83'''\nThen, take those two prime factors and sum all their decimal digits: '''2 + 8 + 3''' which is '''13'''\nThen, take the decimal digits of '''166''' and add their decimal digits: '''1 + 6 + 6''' which is '''13'''\nTherefore, the number '''166''' is a Smith number.\n\n\n;Task\nWrite a program to find all Smith numbers ''below'' 10000.\n\n\n;See also\n* from Wikipedia:   [Smith number].\n* from MathWorld:   [Smith number]. \n* from OEIS A6753:   [OEIS sequence A6753].\n* from OEIS A104170:   [Number of Smith numbers below 10^n]. \n* from The Prime pages:   [Smith numbers].\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nnamespace SmithNumbers {\n    class Program {\n        static int SumDigits(int n) {\n            int sum = 0;\n            while (n > 0) {\n                n = Math.DivRem(n, 10, out int rem);\n                sum += rem;\n            }\n            return sum;\n        }\n\n        static List<int> PrimeFactors(int n) {\n            List<int> result = new List<int>();\n\n            for (int i = 2; n % i == 0; n /= i) {\n                result.Add(i);\n            }\n\n            for (int i = 3; i * i < n; i += 2) {\n                while (n % i == 0) {\n                    result.Add(i);\n                    n /= i;\n                }\n            }\n\n            if (n != 1) {\n                result.Add(n);\n            }\n\n            return result;\n        }\n\n        static void Main(string[] args) {\n            const int SIZE = 8;\n            int count = 0;\n            for (int n = 1; n < 10_000; n++) {\n                var factors = PrimeFactors(n);\n                if (factors.Count > 1) {\n                    int sum = SumDigits(n);\n                    foreach (var f in factors) {\n                        sum -= SumDigits(f);\n                    }\n                    if (sum == 0) {\n                        Console.Write(\"{0,5}\", n);\n                        if (count == SIZE - 1) {\n                            Console.WriteLine();\n                        }\n                        count = (count + 1) % SIZE;\n                    }\n                }\n            }\n        }\n    }\n}"}
{"title": "Soloway's recurring rainfall", "language": "C sharp|C#", "task": "Soloway's Recurring Rainfall is commonly used to assess general programming knowledge by requiring basic program structure, input/output, and program exit procedure.\n\n'''The problem:'''\n\nWrite a program that will read in integers and output their average. Stop reading when the value 99999 is input.\n\nFor languages that aren't traditionally interactive, the program can read in values as makes sense and stopping once 99999 is encountered.  The classic rainfall problem comes from identifying success of Computer Science programs with their students, so the original problem statement is written above -- though it may not strictly apply to a given language in the modern era.\n\n'''Implementation Details:'''\n* Only Integers are to be accepted as input\n* Output should be floating point\n* Rainfall can be negative (https://www.geographyrealm.com/what-is-negative-rainfall/)\n* For languages where the user is inputting data, the number of data inputs can be \"infinite\"\n* A complete implementation should handle error cases reasonably (asking the user for more input, skipping the bad value when encountered, etc)\n\nThe purpose of this problem, as originally proposed in the 1980's through its continued use today, is to just show fundamentals of CS: iteration, branching, program structure, termination, management of data types, input/output (where applicable), etc with things like input validation or management of numerical limits being more \"advanced\".  It isn't meant to literally be a rainfall calculator so implementations should strive to implement the solution clearly and simply.\n\n'''References:'''\n* http://cs.brown.edu/~kfisler/Pubs/icer14-rainfall/icer14.pdf\n* https://www.curriculumonline.ie/getmedia/8bb01bff-509e-48ed-991e-3ab5dad74a78/Seppletal-2015-DoweknowhowdifficulttheRainfallProblemis.pdf\n* https://en.wikipedia.org/wiki/Moving_average#Cumulative_average\n\n\n", "solution": "namespace RosettaCode\n{\n\tclass CSharpRecurringRainfall\n    {\t\t\n\t\tstatic int ReadNextInput()\n\t\t{\n\t\t\tSystem.Console.Write(\"Enter rainfall int, 99999 to quit: \");\n\t\t\tstring input = System.Console.ReadLine();\n\t\t\t\n\t\t\tif (System.Int32.TryParse(input, out int num))\n\t\t\t{\n\t\t\t\treturn num;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tSystem.Console.WriteLine(\"Invalid input\");\n\t\t\t\treturn ReadNextInput();\n\t\t\t}\n\t\t}\n\t\t\n        static void Main()\n        {\n\t\t\tdouble currentAverage = 0;\n\t\t\tint currentEntryNumber = 0;\n\t\t\t\n            for (int lastInput = ReadNextInput(); lastInput != 99999; lastInput = ReadNextInput())\n            {\n\t\t\t\tcurrentEntryNumber++;\n\t\t\t\tcurrentAverage = currentAverage + (1.0/(float)currentEntryNumber)*lastInput - (1.0/(float)currentEntryNumber)*currentAverage;\n\t\t\t\tSystem.Console.WriteLine(\"New Average: \" + currentAverage);\n\t\t\t}\n        }\n    }\n}\n\n"}
{"title": "Solve a Hidato puzzle", "language": "C sharp", "task": "The task is to write a program which solves Hidato (aka Hidoku) puzzles.\n\nThe rules are:\n* You are given a grid with some numbers placed in it. The other squares in the grid will be blank.\n** The grid is not necessarily rectangular.\n** The grid may have holes in it.\n** The grid is always connected.\n** The number \"1\" is always present, as is another number that is equal to the number of squares in the grid. Other numbers are present so as to force the solution to be unique.\n** It may be assumed that the difference between numbers present on the grid is not greater than lucky 13.\n* The aim is to place a natural number in each blank square so that in the sequence of numbered squares from \"1\" upwards, each square is in the [[wp:Moore neighborhood]] of the squares immediately before and after it in the sequence (except for the first and last squares, of course, which only have one-sided constraints).\n** Thus, if the grid was overlaid on a chessboard, a king would be able to make legal moves along the path from first to last square in numerical order.\n** A square may only contain one number.\n* In a proper Hidato puzzle, the solution is unique.\n\nFor example the following problem\nSample Hidato problem, from Wikipedia\n\nhas the following solution, with path marked on it:\n\nSolution to sample Hidato problem\n\n\n;Related tasks:\n* [[A* search algorithm]]\n* [[N-queens problem]]\n* [[Solve a Holy Knight's tour]]\n* [[Solve a Knight's tour]]\n* [[Solve a Hopido puzzle]]\n* [[Solve a Numbrix puzzle]]\n* [[Solve the no connection puzzle]];\n\n", "solution": "using System.Collections;\nusing System.Collections.Generic;\nusing static System.Console;\nusing static System.Math;\nusing static System.Linq.Enumerable;\n\npublic class Solver\n{\n    private static readonly (int dx, int dy)[]\n        //other puzzle types elided\n        hidatoMoves = {(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)};\n\n    private (int dx, int dy)[] moves;\n        \n    public static void Main()\n    {\n        Print(new Solver(hidatoMoves).Solve(false, new [,] {\n            {  0, 33, 35,  0,  0, -1, -1, -1 },\n            {  0,  0, 24, 22,  0, -1, -1, -1 },\n            {  0,  0,  0, 21,  0,  0, -1, -1 },\n            {  0, 26,  0, 13, 40, 11, -1, -1 },\n            { 27,  0,  0,  0,  9,  0,  1, -1 },\n            { -1, -1,  0,  0, 18,  0,  0, -1 },\n            { -1, -1, -1, -1,  0,  7,  0,  0 },\n            { -1, -1, -1, -1, -1, -1,  5,  0 }\n        }));\n    }\n\n    public Solver(params (int dx, int dy)[] moves) => this.moves = moves;\n\n    public int[,] Solve(bool circular, params string[] puzzle)\n    {\n        var (board, given, count) = Parse(puzzle);\n        return Solve(board, given, count, circular);\n    }\n\n    public int[,] Solve(bool circular, int[,] puzzle)\n    {\n        var (board, given, count) = Parse(puzzle);\n        return Solve(board, given, count, circular);\n    }\n\n    private int[,] Solve(int[,] board, BitArray given, int count, bool circular)\n    {\n        var (height, width) = (board.GetLength(0), board.GetLength(1));\n        bool solved = false;\n        for (int x = 0; x < height && !solved; x++) {\n            solved = Range(0, width).Any(y => Solve(board, given, circular, (height, width), (x, y), count, (x, y), 1));\n            if (solved) return board;\n        }\n        return null;\n    }\n\n    private bool Solve(int[,] board, BitArray given, bool circular,\n        (int h, int w) size, (int x, int y) start, int last, (int x, int y) current, int n)\n    {\n        var (x, y) = current;\n        if (x < 0 || x >= size.h || y < 0 || y >= size.w) return false;\n        if (board[x, y] < 0) return false;\n        if (given[n - 1]) {\n            if (board[x, y] != n) return false;\n        } else if (board[x, y] > 0) return false;\n        board[x, y] = n;\n        if (n == last) {\n            if (!circular || AreNeighbors(start, current)) return true;\n        }\n        for (int i = 0; i < moves.Length; i++) {\n            var move = moves[i];\n            if (Solve(board, given, circular, size, start, last, (x + move.dx, y + move.dy), n + 1)) return true;\n        }\n        if (!given[n - 1]) board[x, y] = 0;\n        return false;\n\n        bool AreNeighbors((int x, int y) p1, (int x, int y) p2) => moves.Any(m => (p2.x + m.dx, p2.y + m.dy).Equals(p1));\n    }\n\n    private static (int[,] board, BitArray given, int count) Parse(string[] input)\n    {\n        (int height, int width) = (input.Length, input[0].Length);\n        int[,] board = new int[height, width];\n        int count = 0;\n        for (int x = 0; x < height; x++) {\n            string line = input[x];\n            for (int y = 0; y < width; y++) {\n                board[x, y] = y < line.Length && char.IsDigit(line[y]) ? line[y] - '0' : -1;\n                if (board[x, y] >= 0) count++;\n            }\n        }\n        BitArray given = Scan(board, count, height, width);\n        return (board, given, count);\n    }\n\n    private static (int[,] board, BitArray given, int count) Parse(int[,] input)\n    {\n        (int height, int width) = (input.GetLength(0), input.GetLength(1));\n        int[,] board = new int[height, width];\n        int count = 0;\n        for (int x = 0; x < height; x++)\n            for (int y = 0; y < width; y++)\n                if ((board[x, y] = input[x, y]) >= 0) count++;\n        BitArray given = Scan(board, count, height, width);\n        return (board, given, count);\n    }\n\n    private static BitArray Scan(int[,] board, int count, int height, int width)\n    {\n        var given = new BitArray(count + 1);\n        for (int x = 0; x < height; x++)\n            for (int y = 0; y < width; y++)\n                if (board[x, y] > 0) given[board[x, y] - 1] = true;\n        return given;\n    }\n\n    private static void Print(int[,] board)\n    {\n        if (board == null) {\n            WriteLine(\"No solution\");\n        } else {\n            int w = board.Cast<int>().Where(i => i > 0).Max(i => (int?)Ceiling(Log10(i+1))) ?? 1;\n            string e = new string('-', w);\n            foreach (int x in Range(0, board.GetLength(0)))\n                WriteLine(string.Join(\" \", Range(0, board.GetLength(1))\n                    .Select(y => board[x, y] < 0 ? e : board[x, y].ToString().PadLeft(w, ' '))));\n        }\n        WriteLine();\n    }\n\n}"}
{"title": "Solve a Holy Knight's tour", "language": "C sharp", "task": "Chess coaches have been known to inflict a kind of torture on beginners by taking a chess board, placing pennies on some squares and requiring that a Knight's tour be constructed that avoids the squares with pennies. \n\nThis kind of knight's tour puzzle is similar to   Hidato.\n\nThe present task is to produce a solution to such problems. At least demonstrate your program by solving the following:\n\n\n;Example:\n\n  0 0 0 \n  0   0 0 \n  0 0 0 0 0 0 0\n0 0 0     0   0\n0   0     0 0 0\n1 0 0 0 0 0 0\n    0 0   0\n      0 0 0\n\n\nNote that the zeros represent the available squares, not the pennies.\n\nExtra credit is available for other interesting examples.\n\n\n;Related tasks:\n* [[A* search algorithm]]\n* [[Knight's tour]]\n* [[N-queens problem]]\n* [[Solve a Hidato puzzle]]\n* [[Solve a Hopido puzzle]]\n* [[Solve a Numbrix puzzle]]\n* [[Solve the no connection puzzle]]\n\n", "solution": "using System.Collections;\nusing System.Collections.Generic;\nusing static System.Console;\nusing static System.Math;\nusing static System.Linq.Enumerable;\n\npublic class Solver\n{\n    private static readonly (int dx, int dy)[]\n        //other puzzle types elided\n        knightMoves = {(1,-2),(2,-1),(2,1),(1,2),(-1,2),(-2,1),(-2,-1),(-1,-2)};\n\n    private (int dx, int dy)[] moves;\n        \n    public static void Main()\n    {\n        var knightSolver = new Solver(knightMoves);\n        Print(knightSolver.Solve(true,\n            \".000....\",\n            \".0.00...\",\n            \".0000000\",\n            \"000..0.0\",\n            \"0.0..000\",\n            \"1000000.\",\n            \"..00.0..\",\n            \"...000..\"));\n\n        Print(knightSolver.Solve(true,\n            \".....0.0.....\",\n            \".....0.0.....\",\n            \"....00000....\",\n            \".....000.....\",\n            \"..0..0.0..0..\",\n            \"00000...00000\",\n            \"..00.....00..\",\n            \"00000...00000\",\n            \"..0..0.0..0..\",\n            \".....000.....\",\n            \"....00000....\",\n            \".....0.0.....\",\n            \".....0.0.....\" \n        ));\n    }\n\n    public Solver(params (int dx, int dy)[] moves) => this.moves = moves;\n\n    public int[,] Solve(bool circular, params string[] puzzle)\n    {\n        var (board, given, count) = Parse(puzzle);\n        return Solve(board, given, count, circular);\n    }\n\n    public int[,] Solve(bool circular, int[,] puzzle)\n    {\n        var (board, given, count) = Parse(puzzle);\n        return Solve(board, given, count, circular);\n    }\n\n    private int[,] Solve(int[,] board, BitArray given, int count, bool circular)\n    {\n        var (height, width) = (board.GetLength(0), board.GetLength(1));\n        bool solved = false;\n        for (int x = 0; x < height && !solved; x++) {\n            solved = Range(0, width).Any(y => Solve(board, given, circular, (height, width), (x, y), count, (x, y), 1));\n            if (solved) return board;\n        }\n        return null;\n    }\n\n    private bool Solve(int[,] board, BitArray given, bool circular,\n        (int h, int w) size, (int x, int y) start, int last, (int x, int y) current, int n)\n    {\n        var (x, y) = current;\n        if (x < 0 || x >= size.h || y < 0 || y >= size.w) return false;\n        if (board[x, y] < 0) return false;\n        if (given[n - 1]) {\n            if (board[x, y] != n) return false;\n        } else if (board[x, y] > 0) return false;\n        board[x, y] = n;\n        if (n == last) {\n            if (!circular || AreNeighbors(start, current)) return true;\n        }\n        for (int i = 0; i < moves.Length; i++) {\n            var move = moves[i];\n            if (Solve(board, given, circular, size, start, last, (x + move.dx, y + move.dy), n + 1)) return true;\n        }\n        if (!given[n - 1]) board[x, y] = 0;\n        return false;\n\n        bool AreNeighbors((int x, int y) p1, (int x, int y) p2) => moves.Any(m => (p2.x + m.dx, p2.y + m.dy).Equals(p1));\n    }\n\n    private static (int[,] board, BitArray given, int count) Parse(string[] input)\n    {\n        (int height, int width) = (input.Length, input[0].Length);\n        int[,] board = new int[height, width];\n        int count = 0;\n        for (int x = 0; x < height; x++) {\n            string line = input[x];\n            for (int y = 0; y < width; y++) {\n                board[x, y] = y < line.Length && char.IsDigit(line[y]) ? line[y] - '0' : -1;\n                if (board[x, y] >= 0) count++;\n            }\n        }\n        BitArray given = Scan(board, count, height, width);\n        return (board, given, count);\n    }\n\n    private static (int[,] board, BitArray given, int count) Parse(int[,] input)\n    {\n        (int height, int width) = (input.GetLength(0), input.GetLength(1));\n        int[,] board = new int[height, width];\n        int count = 0;\n        for (int x = 0; x < height; x++)\n            for (int y = 0; y < width; y++)\n                if ((board[x, y] = input[x, y]) >= 0) count++;\n        BitArray given = Scan(board, count, height, width);\n        return (board, given, count);\n    }\n\n    private static BitArray Scan(int[,] board, int count, int height, int width)\n    {\n        var given = new BitArray(count + 1);\n        for (int x = 0; x < height; x++)\n            for (int y = 0; y < width; y++)\n                if (board[x, y] > 0) given[board[x, y] - 1] = true;\n        return given;\n    }\n\n    private static void Print(int[,] board)\n    {\n        if (board == null) {\n            WriteLine(\"No solution\");\n        } else {\n            int w = board.Cast<int>().Where(i => i > 0).Max(i => (int?)Ceiling(Log10(i+1))) ?? 1;\n            string e = new string('-', w);\n            foreach (int x in Range(0, board.GetLength(0)))\n                WriteLine(string.Join(\" \", Range(0, board.GetLength(1))\n                    .Select(y => board[x, y] < 0 ? e : board[x, y].ToString().PadLeft(w, ' '))));\n        }\n        WriteLine();\n    }\n\n}"}
{"title": "Solve a Hopido puzzle", "language": "C sharp", "task": "Hopido puzzles are similar to  Hidato. The most important difference is that the only moves allowed are:  hop over one tile diagonally; and over two tiles horizontally and vertically. It should be possible to start anywhere in the path, the end point isn't indicated and there are no intermediate clues. Hopido Design Post Mortem contains the following:\n\n\"Big puzzles represented another problem. Up until quite late in the project our puzzle solver was painfully slow with most puzzles above 7x7 tiles. Testing the solution from each starting point could take hours. If the tile layout was changed even a little, the whole puzzle had to be tested again. We were just about to give up the biggest puzzles entirely when our programmer suddenly came up with a magical algorithm that cut the testing process down to only minutes. Hooray!\"\n\nKnowing the kindness in the heart of every contributor to Rosetta Code, I know that we shall feel that as an act of humanity we must solve these puzzles for them in let's say milliseconds.\n\nExample:\n\n . 0 0 . 0 0 .\n 0 0 0 0 0 0 0\n 0 0 0 0 0 0 0\n . 0 0 0 0 0 .\n . . 0 0 0 . .\n . . . 0 . . .\n\nExtra credits are available for other interesting designs.\n\n\n;Related tasks:\n* [[A* search algorithm]]\n* [[Solve a Holy Knight's tour]]\n* [[Knight's tour]]\n* [[N-queens problem]]\n* [[Solve a Hidato puzzle]]\n* [[Solve a Holy Knight's tour]]\n* [[Solve a Numbrix puzzle]]\n* [[Solve the no connection puzzle]]\n\n", "solution": "using System.Collections;\nusing System.Collections.Generic;\nusing static System.Console;\nusing static System.Math;\nusing static System.Linq.Enumerable;\n\npublic class Solver\n{\n    private static readonly (int dx, int dy)[]\n        //other puzzle types elided\n        hopidoMoves = {(-3,0),(0,-3),(0,3),(3,0),(-2,-2),(-2,2),(2,-2),(2,2)},\n\n    private (int dx, int dy)[] moves;\n        \n    public static void Main()\n    {\n        Print(new Solver(hopidoMoves).Solve(false,\n            \".00.00.\",\n            \"0000000\",\n            \"0000000\",\n            \".00000.\",\n            \"..000..\",\n            \"...0...\"\n        ));\n    }\n\n    public Solver(params (int dx, int dy)[] moves) => this.moves = moves;\n\n    public int[,] Solve(bool circular, params string[] puzzle)\n    {\n        var (board, given, count) = Parse(puzzle);\n        return Solve(board, given, count, circular);\n    }\n\n    public int[,] Solve(bool circular, int[,] puzzle)\n    {\n        var (board, given, count) = Parse(puzzle);\n        return Solve(board, given, count, circular);\n    }\n\n    private int[,] Solve(int[,] board, BitArray given, int count, bool circular)\n    {\n        var (height, width) = (board.GetLength(0), board.GetLength(1));\n        bool solved = false;\n        for (int x = 0; x < height && !solved; x++) {\n            solved = Range(0, width).Any(y => Solve(board, given, circular, (height, width), (x, y), count, (x, y), 1));\n            if (solved) return board;\n        }\n        return null;\n    }\n\n    private bool Solve(int[,] board, BitArray given, bool circular,\n        (int h, int w) size, (int x, int y) start, int last, (int x, int y) current, int n)\n    {\n        var (x, y) = current;\n        if (x < 0 || x >= size.h || y < 0 || y >= size.w) return false;\n        if (board[x, y] < 0) return false;\n        if (given[n - 1]) {\n            if (board[x, y] != n) return false;\n        } else if (board[x, y] > 0) return false;\n        board[x, y] = n;\n        if (n == last) {\n            if (!circular || AreNeighbors(start, current)) return true;\n        }\n        for (int i = 0; i < moves.Length; i++) {\n            var move = moves[i];\n            if (Solve(board, given, circular, size, start, last, (x + move.dx, y + move.dy), n + 1)) return true;\n        }\n        if (!given[n - 1]) board[x, y] = 0;\n        return false;\n\n        bool AreNeighbors((int x, int y) p1, (int x, int y) p2) => moves.Any(m => (p2.x + m.dx, p2.y + m.dy).Equals(p1));\n    }\n\n    private static (int[,] board, BitArray given, int count) Parse(string[] input)\n    {\n        (int height, int width) = (input.Length, input[0].Length);\n        int[,] board = new int[height, width];\n        int count = 0;\n        for (int x = 0; x < height; x++) {\n            string line = input[x];\n            for (int y = 0; y < width; y++) {\n                board[x, y] = y < line.Length && char.IsDigit(line[y]) ? line[y] - '0' : -1;\n                if (board[x, y] >= 0) count++;\n            }\n        }\n        BitArray given = Scan(board, count, height, width);\n        return (board, given, count);\n    }\n\n    private static (int[,] board, BitArray given, int count) Parse(int[,] input)\n    {\n        (int height, int width) = (input.GetLength(0), input.GetLength(1));\n        int[,] board = new int[height, width];\n        int count = 0;\n        for (int x = 0; x < height; x++)\n            for (int y = 0; y < width; y++)\n                if ((board[x, y] = input[x, y]) >= 0) count++;\n        BitArray given = Scan(board, count, height, width);\n        return (board, given, count);\n    }\n\n    private static BitArray Scan(int[,] board, int count, int height, int width)\n    {\n        var given = new BitArray(count + 1);\n        for (int x = 0; x < height; x++)\n            for (int y = 0; y < width; y++)\n                if (board[x, y] > 0) given[board[x, y] - 1] = true;\n        return given;\n    }\n\n    private static void Print(int[,] board)\n    {\n        if (board == null) {\n            WriteLine(\"No solution\");\n        } else {\n            int w = board.Cast<int>().Where(i => i > 0).Max(i => (int?)Ceiling(Log10(i+1))) ?? 1;\n            string e = new string('-', w);\n            foreach (int x in Range(0, board.GetLength(0)))\n                WriteLine(string.Join(\" \", Range(0, board.GetLength(1))\n                    .Select(y => board[x, y] < 0 ? e : board[x, y].ToString().PadLeft(w, ' '))));\n        }\n        WriteLine();\n    }\n\n}"}
{"title": "Solve a Numbrix puzzle", "language": "C sharp", "task": "Numbrix puzzles are similar to Hidato. \nThe most important difference is that it is only possible to move 1 node left, right, up, or down (sometimes referred to as the Von Neumann neighborhood). \nPublished puzzles also tend not to have holes in the grid and may not always indicate the end node. \nTwo examples follow:\n\n;Example 1\nProblem.\n\n 0  0  0  0  0  0  0  0  0\n 0  0 46 45  0 55 74  0  0\n 0 38  0  0 43  0  0 78  0\n 0 35  0  0  0  0  0 71  0\n 0  0 33  0  0  0 59  0  0\n 0 17  0  0  0  0  0 67  0\n 0 18  0  0 11  0  0 64  0\n 0  0 24 21  0  1  2  0  0\n 0  0  0  0  0  0  0  0  0\n\nSolution.\n\n 49 50 51 52 53 54 75 76 81\n 48 47 46 45 44 55 74 77 80\n 37 38 39 40 43 56 73 78 79\n 36 35 34 41 42 57 72 71 70\n 31 32 33 14 13 58 59 68 69\n 30 17 16 15 12 61 60 67 66\n 29 18 19 20 11 62 63 64 65\n 28 25 24 21 10  1  2  3  4\n 27 26 23 22  9  8  7  6  5\n\n;Example 2\nProblem.\n\n 0  0  0  0  0  0  0  0  0\n 0 11 12 15 18 21 62 61  0\n 0  6  0  0  0  0  0 60  0\n 0 33  0  0  0  0  0 57  0\n 0 32  0  0  0  0  0 56  0\n 0 37  0  1  0  0  0 73  0\n 0 38  0  0  0  0  0 72  0\n 0 43 44 47 48 51 76 77  0\n 0  0  0  0  0  0  0  0  0\n\nSolution.\n\n  9 10 13 14 19 20 63 64 65\n  8 11 12 15 18 21 62 61 66\n  7  6  5 16 17 22 59 60 67\n 34 33  4  3 24 23 58 57 68\n 35 32 31  2 25 54 55 56 69\n 36 37 30  1 26 53 74 73 70\n 39 38 29 28 27 52 75 72 71\n 40 43 44 47 48 51 76 77 78\n 41 42 45 46 49 50 81 80 79\n\n;Task\nWrite a program to solve puzzles of this ilk, \ndemonstrating your program by solving the above examples. \nExtra credit for other interesting examples.\n\n\n;Related tasks:\n* [[A* search algorithm]]\n* [[Solve a Holy Knight's tour]]\n* [[Knight's tour]]\n* [[N-queens problem]]\n* [[Solve a Hidato puzzle]]\n* [[Solve a Holy Knight's tour]]\n* [[Solve a Hopido puzzle]]\n* [[Solve the no connection puzzle]]\n\n", "solution": "using System.Collections;\nusing System.Collections.Generic;\nusing static System.Console;\nusing static System.Math;\nusing static System.Linq.Enumerable;\n\npublic class Solver\n{\n    private static readonly (int dx, int dy)[]\n        //other puzzle types elided\n        numbrixMoves = {(1,0),(0,1),(-1,0),(0,-1)};\n\n    private (int dx, int dy)[] moves;\n        \n    public static void Main()\n    {\n        var numbrixSolver = new Solver(numbrixMoves);\n        Print(numbrixSolver.Solve(false, new [,] {\n            {  0,  0,  0,  0,  0,  0,  0,  0,  0 },\n            {  0,  0, 46, 45,  0, 55, 74,  0,  0 },\n            {  0, 38,  0,  0, 43,  0,  0, 78,  0 },\n            {  0, 35,  0,  0,  0,  0,  0, 71,  0 },\n            {  0,  0, 33,  0,  0,  0, 59,  0,  0 },\n            {  0, 17,  0,  0,  0,  0,  0, 67,  0 },\n            {  0, 18,  0,  0, 11,  0,  0, 64,  0 },\n            {  0,  0, 24, 21,  0,  1,  2,  0,  0 },\n            {  0,  0,  0,  0,  0,  0,  0,  0,  0 },\n        }));\n\n        Print(numbrixSolver.Solve(false, new [,] {\n            {  0,  0,  0,  0,  0,  0,  0,  0,  0 },\n            {  0, 11, 12, 15, 18, 21, 62, 61,  0 },\n            {  0,  6,  0,  0,  0,  0,  0, 60,  0 },\n            {  0, 33,  0,  0,  0,  0,  0, 57,  0 },\n            {  0, 32,  0,  0,  0,  0,  0, 56,  0 },\n            {  0, 37,  0,  1,  0,  0,  0, 73,  0 },\n            {  0, 38,  0,  0,  0,  0,  0, 72,  0 },\n            {  0, 43, 44, 47, 48, 51, 76, 77,  0 },\n            {  0,  0,  0,  0,  0,  0,  0,  0,  0 },\n        }));\n    }\n\n    public Solver(params (int dx, int dy)[] moves) => this.moves = moves;\n\n    public int[,] Solve(bool circular, params string[] puzzle)\n    {\n        var (board, given, count) = Parse(puzzle);\n        return Solve(board, given, count, circular);\n    }\n\n    public int[,] Solve(bool circular, int[,] puzzle)\n    {\n        var (board, given, count) = Parse(puzzle);\n        return Solve(board, given, count, circular);\n    }\n\n    private int[,] Solve(int[,] board, BitArray given, int count, bool circular)\n    {\n        var (height, width) = (board.GetLength(0), board.GetLength(1));\n        bool solved = false;\n        for (int x = 0; x < height && !solved; x++) {\n            solved = Range(0, width).Any(y => Solve(board, given, circular, (height, width), (x, y), count, (x, y), 1));\n            if (solved) return board;\n        }\n        return null;\n    }\n\n    private bool Solve(int[,] board, BitArray given, bool circular,\n        (int h, int w) size, (int x, int y) start, int last, (int x, int y) current, int n)\n    {\n        var (x, y) = current;\n        if (x < 0 || x >= size.h || y < 0 || y >= size.w) return false;\n        if (board[x, y] < 0) return false;\n        if (given[n - 1]) {\n            if (board[x, y] != n) return false;\n        } else if (board[x, y] > 0) return false;\n        board[x, y] = n;\n        if (n == last) {\n            if (!circular || AreNeighbors(start, current)) return true;\n        }\n        for (int i = 0; i < moves.Length; i++) {\n            var move = moves[i];\n            if (Solve(board, given, circular, size, start, last, (x + move.dx, y + move.dy), n + 1)) return true;\n        }\n        if (!given[n - 1]) board[x, y] = 0;\n        return false;\n\n        bool AreNeighbors((int x, int y) p1, (int x, int y) p2) => moves.Any(m => (p2.x + m.dx, p2.y + m.dy).Equals(p1));\n    }\n\n    private static (int[,] board, BitArray given, int count) Parse(string[] input)\n    {\n        (int height, int width) = (input.Length, input[0].Length);\n        int[,] board = new int[height, width];\n        int count = 0;\n        for (int x = 0; x < height; x++) {\n            string line = input[x];\n            for (int y = 0; y < width; y++) {\n                board[x, y] = y < line.Length && char.IsDigit(line[y]) ? line[y] - '0' : -1;\n                if (board[x, y] >= 0) count++;\n            }\n        }\n        BitArray given = Scan(board, count, height, width);\n        return (board, given, count);\n    }\n\n    private static (int[,] board, BitArray given, int count) Parse(int[,] input)\n    {\n        (int height, int width) = (input.GetLength(0), input.GetLength(1));\n        int[,] board = new int[height, width];\n        int count = 0;\n        for (int x = 0; x < height; x++)\n            for (int y = 0; y < width; y++)\n                if ((board[x, y] = input[x, y]) >= 0) count++;\n        BitArray given = Scan(board, count, height, width);\n        return (board, given, count);\n    }\n\n    private static BitArray Scan(int[,] board, int count, int height, int width)\n    {\n        var given = new BitArray(count + 1);\n        for (int x = 0; x < height; x++)\n            for (int y = 0; y < width; y++)\n                if (board[x, y] > 0) given[board[x, y] - 1] = true;\n        return given;\n    }\n\n    private static void Print(int[,] board)\n    {\n        if (board == null) {\n            WriteLine(\"No solution\");\n        } else {\n            int w = board.Cast<int>().Where(i => i > 0).Max(i => (int?)Ceiling(Log10(i+1))) ?? 1;\n            string e = new string('-', w);\n            foreach (int x in Range(0, board.GetLength(0)))\n                WriteLine(string.Join(\" \", Range(0, board.GetLength(1))\n                    .Select(y => board[x, y] < 0 ? e : board[x, y].ToString().PadLeft(w, ' '))));\n        }\n        WriteLine();\n    }\n\n}"}
{"title": "Split a character string based on change of character", "language": "C sharp", "task": "Split a (character) string into comma (plus a blank) delimited\nstrings based on a change of character   (left to right).\n\nShow the output here   (use the 1st example below).\n\n\nBlanks should be treated as any other character   (except\nthey are problematic to display clearly).   The same applies\nto commas.\n\n\nFor instance, the string: \n  gHHH5YY++///\\ \nshould be split and show:  \n  g, HHH, 5, YY, ++, ///, \\ \n\n", "solution": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\npublic class Program\n{\n    string s = @\"gHHH5YY++///\\\";\n    Console.WriteLine(s.RunLengthSplit().Delimit(\", \"));\n}\n\npublic static class Extensions\n{\n    public static IEnumerable<string> RunLengthSplit(this string source) {\n        using (var enumerator = source.GetEnumerator()) {\n            if (!enumerator.MoveNext()) yield break;\n            char previous = enumerator.Current;\n            int count = 1;\n            while (enumerator.MoveNext()) {\n                if (previous == enumerator.Current) {\n                    count++;\n                } else {\n                    yield return new string(Enumerable.Repeat(previous, count).ToArray());\n                    previous = enumerator.Current;\n                    count = 1;\n                }\n            }\n            yield return new string(Enumerable.Repeat(previous, count).ToArray());\n        }\n    }\n\n    public static string Delimit<T>(this IEnumerable<T> source, string separator = \"\") => string.Join(separator ?? \"\", source);\n}"}
{"title": "Square but not cube", "language": "C sharp", "task": "Show the first   '''30'''   positive integers which are squares but not cubes of such integers.\n\nOptionally, show also the first   '''3'''   positive integers which are both squares and cubes,   and mark them as such.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing static System.Console;\nusing static System.Linq.Enumerable;\n\npublic static class SquareButNotCube\n{\n    public static void Main() {\n        var squares = from i in Integers() select i * i;\n        var cubes = from i in Integers() select i * i * i;\n\n        foreach (var x in Merge().Take(33)) {\n            WriteLine(x.isCube ? x.n + \" (also cube)\" : x.n + \"\");\n        }\n        \n        IEnumerable<int> Integers() {\n            for (int i = 1; ;i++) yield return i;\n        }\n\n        IEnumerable<(int n, bool isCube)> Merge() {\n            using (var s = squares.GetEnumerator())\n            using (var c = cubes.GetEnumerator()) {\n                s.MoveNext();\n                c.MoveNext();\n                while (true) {\n                    if (s.Current < c.Current) {\n                        yield return (s.Current, false);\n                        s.MoveNext();\n                    } else if (s.Current == c.Current) {\n                        yield return (s.Current, true);\n                        s.MoveNext();\n                        c.MoveNext();\n                    } else {\n                        c.MoveNext();\n                    }\n                }\n            }\n        }\n\n    }\n}"}
{"title": "Stern-Brocot sequence", "language": "C sharp|C#", "task": "For this task, the Stern-Brocot sequence is to be generated by an algorithm similar to that employed in generating the [[Fibonacci sequence]].\n\n# The first and second members of the sequence are both 1:\n#*     1, 1\n# Start by considering the second member of the sequence\n# Sum the considered member of the sequence and its precedent, (1 + 1) = 2, and append it to the end of the sequence:\n#*     1, 1, 2\n# Append the considered member of the sequence to the end of the sequence:\n#*     1, 1, 2, 1\n# Consider the next member of the series, (the third member i.e. 2)\n# GOTO 3\n#*\n#*         --- Expanding another loop we get: ---\n#*\n# Sum the considered member of the sequence and its precedent, (2 + 1) = 3, and append it to the end of the sequence:\n#*     1, 1, 2, 1, 3\n# Append the considered member of the sequence to the end of the sequence:\n#*     1, 1, 2, 1, 3, 2\n# Consider the next member of the series, (the fourth member i.e. 1)\n\n\n;The task is to:\n* Create a function/method/subroutine/procedure/... to generate the Stern-Brocot sequence of integers using the method outlined above.\n* Show the first fifteen members of the sequence. (This should be: 1, 1, 2, 1, 3, 2, 3, 1, 4, 3, 5, 2, 5, 3, 4)\n* Show the (1-based) index of where the numbers 1-to-10 first appear in the sequence.\n* Show the (1-based) index of where the number 100 first appears in the sequence.\n* Check that the greatest common divisor of all the two consecutive members of the series up to the 1000th member, is always one.\n\nShow your output on this page.\n\n\n;Related tasks:\n:*   [[Fusc sequence]].\n:*   [[Continued fraction/Arithmetic]]\n\n\n;Ref:\n* Infinite Fractions - Numberphile (Video).\n* Trees, Teeth, and Time: The mathematics of clock making.\n* A002487 The On-Line Encyclopedia of Integer Sequences.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nstatic class Program {\n    static List<int> l = new List<int>() { 1, 1 };\n\n    static int gcd(int a, int b) {\n        return a > 0 ? a < b ? gcd(b % a, a) : gcd(a % b, b) : b; }\n\n    static void Main(string[] args) {\n        int max = 1000; int take = 15; int i = 1;\n        int[] selection = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100 };\n        do { l.AddRange(new List<int>() { l[i] + l[i - 1], l[i] }); i += 1; }\n        while (l.Count < max || l[l.Count - 2] != selection.Last());\n        Console.Write(\"The first {0} items In the Stern-Brocot sequence: \", take);\n        Console.WriteLine(\"{0}\\n\", string.Join(\", \", l.Take(take)));\n        Console.WriteLine(\"The locations of where the selected numbers (1-to-10, & 100) first appear:\");\n        foreach (int ii in selection) {\n            int j = l.FindIndex(x => x == ii) + 1; Console.WriteLine(\"{0,3}: {1:n0}\", ii, j); }\n        Console.WriteLine(); bool good = true;\n        for (i = 1; i <= max; i++) { if (gcd(l[i], l[i - 1]) != 1) { good = false; break; } }\n        Console.WriteLine(\"The greatest common divisor of all the two consecutive items of the\" + \n                          \" series up to the {0}th item is {1}always one.\", max, good ? \"\" : \"not \");\n    }\n}"}
{"title": "Stream merge", "language": "C sharp|C#", "task": " 2-stream merge\n: Read two sorted streams of items from external source (e.g. disk, or network), and write one stream of sorted items to external sink.\n: Common algorithm: keep 1 buffered item from each source, select minimal of them, write it, fetch another item from that stream from which the written item was.\n\n; ''N''-stream merge\n: The same as above, but reading from    ''N''    sources.\n: Common algorithm: same as above, but keep buffered items and their source descriptors in a [[heap]].\n\n\nAssume streams are very big. You must not suck them whole in the memory, but read them as streams.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace RosettaCode\n{\n    static class StreamMerge\n    {\n        static IEnumerable<T> Merge2<T>(IEnumerable<T> source1, IEnumerable<T> source2) where T : IComparable\n        {\n            var q1 = new Queue<T>(source1);\n            var q2 = new Queue<T>(source2);\n            while (q1.Any() && q2.Any())\n            {\n                var c = q1.Peek().CompareTo(q2.Peek());\n                if (c <= 0) yield return q1.Dequeue(); else yield return q2.Dequeue();\n            }\n            while (q1.Any()) yield return q1.Dequeue();\n            while (q2.Any()) yield return q2.Dequeue();\n        }\n\n        static IEnumerable<T> MergeN<T>(params IEnumerable<T>[] sources) where T : IComparable\n        {\n            var queues = sources.Select(e => new Queue<T>(e)).Where(q => q.Any()).ToList();\n            var headComparer = Comparer<Queue<T>>.Create((x, y) => x.Peek().CompareTo(y.Peek()));\n            queues.Sort(headComparer);\n            \n            while (queues.Any())\n            {\n                var q = queues.First();\n                queues.RemoveAt(0);\n                yield return q.Dequeue();\n                if (q.Any())\n                {\n                    var index = queues.BinarySearch(q, headComparer);\n                    queues.Insert(index < 0 ? ~index : index, q);\n                }\n            }\n        }\n\n        static void Main()\n        {\n            var a = new[] { 1, 4, 7, 10 };\n            var b = new[] { 2, 5, 8, 11 };\n            var c = new[] { 3, 6, 9, 12 };\n\n            foreach (var i in Merge2(a, b)) Console.Write($\"{i} \");\n            Console.WriteLine();\n\n            foreach (var i in MergeN(a, b, c)) Console.Write($\"{i} \");\n            Console.WriteLine();\n        }\n    }\n}"}
{"title": "Strip control codes and extended characters from a string", "language": "C sharp|C#", "task": "Strip control codes and extended characters from a string. \n\n\nThe solution should demonstrate how to achieve each of the following results:\n:*   a string with control codes stripped (but extended characters not stripped)\n:*   a string with control codes and extended characters stripped\n\n\nIn ASCII, the control codes have decimal codes 0 through to 31 and 127. \n\nOn an ASCII based system, if the control codes are stripped, the resultant string would have all of its characters within the range of 32 to 126 decimal on the ASCII table.\n\nOn a non-ASCII based system, we consider characters that do not have a corresponding glyph on the ASCII table (within the ASCII range of 32 to 126 decimal) to be an extended character for the purpose of this task.\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\n\nnamespace RosettaCode\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            string test = \"string of \u263a\u263b\u2665\u2666\u2302, may include control characters and other ilk.\u266b\u263c\u00a7\u25ba\u2194\u25c4\";\n            Console.WriteLine(\"Original: {0}\", test);\n            Console.WriteLine(\"Stripped of control codes: {0}\", StripControlChars(test));\n            Console.WriteLine(\"Stripped of extended: {0}\", StripExtended(test));\n        }\n\n        static string StripControlChars(string arg)\n        {\n            char[] arrForm = arg.ToCharArray();\n            StringBuilder buffer = new StringBuilder(arg.Length);//This many chars at most\n            \n            foreach(char ch in arrForm)\n                if (!Char.IsControl(ch)) buffer.Append(ch);//Only add to buffer if not a control char\n\n            return buffer.ToString();\n        }\n\n        static string StripExtended(string arg)\n        {\n            StringBuilder buffer = new StringBuilder(arg.Length); //Max length\n            foreach(char ch in arg)\n            {\n                UInt16 num = Convert.ToUInt16(ch);//In .NET, chars are UTF-16\n                //The basic characters have the same code points as ASCII, and the extended characters are bigger\n                if((num >= 32u) && (num <= 126u)) buffer.Append(ch);\n            }\n            return buffer.ToString();\n        }\n    }\n}\n"}
{"title": "Subleq", "language": "C sharp|C# from Java", "task": "One-Instruction Set Computer (OISC). \n\nIt is named after its only instruction, which is '''SU'''btract and '''B'''ranch if '''L'''ess than or '''EQ'''ual to zero.  \n\n;Task\nYour task is to create an interpreter which emulates a SUBLEQ machine.\n\nThe machine's memory consists of an array of signed integers.   These integers may be interpreted in three ways:\n::::*   simple numeric values \n::::*   memory addresses \n::::*   characters for input or output\n\nAny reasonable word size that accommodates all three of the above uses is fine. \n\nThe program should load the initial contents of the emulated machine's memory, set the instruction pointer to the first address (which is defined to be address 0), and begin emulating the machine, which works as follows:\n:#   Let '''A''' be the value in the memory location identified by the instruction pointer;   let '''B''' and '''C''' be the values stored in the next two consecutive addresses in memory.\n:#   Advance the instruction pointer three words, to point at the address ''after'' the address containing '''C'''.\n:#   If '''A''' is   '''-1'''   (negative unity),   then a character is read from the machine's input and its numeric value stored in the address given by '''B'''.   '''C''' is unused.\n:#   If '''B''' is   '''-1'''   (negative unity),   then the number contained in the address given by '''A''' is interpreted as a character and written to the machine's output.   '''C''' is unused.\n:#   Otherwise, both '''A''' and '''B''' are treated as addresses.   The number contained in address '''A''' is subtracted from the number in address '''B''' (and the difference left in address '''B''').   If the result is positive, execution continues uninterrupted; if the result is zero or negative, the number in '''C''' becomes the new instruction pointer.\n:#   If the instruction pointer becomes negative, execution halts.\n\nYour solution may initialize the emulated machine's memory in any convenient manner, but if you accept it as input, it should be a separate input stream from the one fed to the emulated machine once it is running. And if fed as text input, it should be in the form of raw subleq \"machine code\" - whitespace-separated decimal numbers, with no symbolic names or other assembly-level extensions, to be loaded into memory starting at address   '''0'''   (zero).\n\nFor purposes of this task, show the output of your solution when fed the below   \"Hello, world!\"   program. \n\nAs written, this example assumes ASCII or a superset of it, such as any of the Latin-N character sets or Unicode;   you may translate the numbers representing characters (starting with 72=ASCII 'H') into another character set if your implementation runs in a non-ASCII-compatible environment. If 0 is not an appropriate terminator in your character set, the program logic will need some adjustment as well.\n\n15 17 -1 17 -1 -1 16 1 -1 16 3 -1 15 15 0 0 -1 72 101 108 108 111 44 32 119 111 114 108 100 33 10 0\n\nThe above \"machine code\" corresponds to something like this in a hypothetical assembler language for a signed 8-bit version of the machine:\n\nstart:\n    0f 11 ff subleq (zero), (message), -1\n    11 ff ff subleq (message), -1, -1    ; output character at message\n    10 01 ff subleq (neg1), (start+1), -1\n    10 03 ff subleq (neg1), (start+3), -1\n    0f 0f 00 subleq (zero), (zero), start\n; useful constants\nzero: \n    00      .data 0  \nneg1: \n    ff      .data -1\n; the message to print\nmessage: .data \"Hello, world!\\n\\0\"\n    48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 0a 00\n\n", "solution": "using System;\n\nnamespace Subleq {\n    class Program {\n        static void Main(string[] args) {\n            int[] mem = {\n                15, 17, -1, 17, -1, -1, 16, 1, -1, 16,\n                3, -1, 15, 15, 0, 0, -1, 72, 101, 108,\n                108, 111, 44, 32, 119, 111, 114, 108, 100, 33,\n                10, 0,\n            };\n\n            int instructionPointer = 0;\n\n            do {\n                int a = mem[instructionPointer];\n                int b = mem[instructionPointer + 1];\n\n                if (a == -1) {\n                    mem[b] = Console.Read();\n                }\n                else if (b == -1) {\n                    Console.Write((char)mem[a]);\n                }\n                else {\n                    mem[b] -= mem[a];\n                    if (mem[b] < 1) {\n                        instructionPointer = mem[instructionPointer + 2];\n                        continue;\n                    }\n                }\n\n                instructionPointer += 3;\n            } while (instructionPointer >= 0);\n        }\n    }\n}"}
{"title": "Substring/Top and tail", "language": "C sharp", "task": "The task is to demonstrate how to remove the first and last characters from a string. \n\nThe solution should demonstrate how to obtain the following results:\n\n* String with first character removed\n* String with last character removed\n* String with both the first and last characters removed\n\n\nIf the program uses UTF-8 or UTF-16, it must work on any valid Unicode code point, whether in the Basic Multilingual Plane or above it. \n\nThe program must reference logical characters (code points), not 8-bit code units for UTF-8 or 16-bit code units for UTF-16. \n\nPrograms for other encodings (such as 8-bit ASCII, or EUC-JP) are not required to handle all Unicode characters.\n\n\n\n", "solution": "using System;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        string testString = \"test\";\n        Console.WriteLine(testString.Substring(1));\n        Console.WriteLine(testString.Substring(0, testString.Length - 1));\n        Console.WriteLine(testString.Substring(1, testString.Length - 2));\n    }\n}\n"}
{"title": "Sum and product puzzle", "language": "C sharp", "task": "*   Wikipedia:   Sum and Product Puzzle\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\npublic class Program\n{\n    public static void Main()\n    {\n        const int maxSum = 100;\n        var pairs = (\n            from X in 2.To(maxSum / 2 - 1)\n            from Y in (X + 1).To(maxSum - 2).TakeWhile(y => X + y <= maxSum)\n            select new { X, Y, S = X + Y, P = X * Y }\n            ).ToHashSet();\n\n        Console.WriteLine(pairs.Count);\n        \n        var uniqueP = pairs.GroupBy(pair => pair.P).Where(g => g.Count() == 1).Select(g => g.Key).ToHashSet();\n        \n        pairs.ExceptWith(pairs.GroupBy(pair => pair.S).Where(g => g.Any(pair => uniqueP.Contains(pair.P))).SelectMany(g => g));\n        Console.WriteLine(pairs.Count);\n        \n        pairs.ExceptWith(pairs.GroupBy(pair => pair.P).Where(g => g.Count() > 1).SelectMany(g => g));\n        Console.WriteLine(pairs.Count);\n        \n        pairs.ExceptWith(pairs.GroupBy(pair => pair.S).Where(g => g.Count() > 1).SelectMany(g => g));\n        Console.WriteLine(pairs.Count);\n        \n        foreach (var pair in pairs) Console.WriteLine(pair);\n    }\n}\n\npublic static class Extensions\n{\n    public static IEnumerable<int> To(this int start, int end) {\n        for (int i = start; i <= end; i++) yield return i;\n    }\n    \n    public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source) => new HashSet<T>(source);\n}"}
{"title": "Sum digits of an integer", "language": "C sharp|C#", "task": "Take a   Natural Number   in a given base and return the sum of its digits:\n:*   '''1'''10                  sums to   '''1'''\n:*   '''1234'''10       sums to   '''10'''\n:*   '''fe'''16              sums to   '''29'''\n:*   '''f0e'''16           sums to   '''29'''\n\n", "solution": "namespace RosettaCode.SumDigitsOfAnInteger\n{\n    using System;\n    using System.Collections.Generic;\n    using System.Linq;\n\n    internal static class Program\n    {\n        /// <summary>\n        ///     Enumerates the digits of a number in a given base.\n        /// </summary>\n        /// <param name=\"number\"> The number. </param>\n        /// <param name=\"base\"> The base. </param>\n        /// <returns> The digits of the number in the given base. </returns>\n        /// <remarks>\n        ///     The digits are enumerated from least to most significant.\n        /// </remarks>\n        private static IEnumerable<int> Digits(this int number, int @base = 10)\n        {\n            while (number != 0)\n            {\n                int digit;\n                number = Math.DivRem(number, @base, out digit);\n                yield return digit;\n            }\n        }\n\n        /// <summary>\n        ///     Sums the digits of a number in a given base.\n        /// </summary>\n        /// <param name=\"number\"> The number. </param>\n        /// <param name=\"base\"> The base. </param>\n        /// <returns> The sum of the digits of the number in the given base. </returns>\n        private static int SumOfDigits(this int number, int @base = 10)\n        {\n            return number.Digits(@base).Sum();\n        }\n\n        /// <summary>\n        ///     Demonstrates <see cref=\"SumOfDigits\" />.\n        /// </summary>\n        private static void Main()\n        {\n            foreach (var example in\n                new[]\n                {\n                    new {Number = 1, Base = 10},\n                    new {Number = 12345, Base = 10},\n                    new {Number = 123045, Base = 10},\n                    new {Number = 0xfe, Base = 0x10},\n                    new {Number = 0xf0e, Base = 0x10}\n                })\n            {\n                Console.WriteLine(example.Number.SumOfDigits(example.Base));\n            }\n        }\n    }\n}"}
{"title": "Sum multiples of 3 and 5", "language": "C sharp|C#", "task": "The objective is to write a function that finds the sum of all positive multiples of 3 or 5 below ''n''. \n\nShow output for ''n'' = 1000.\n\nThis is is the same as Project Euler problem 1.\n\n'''Extra credit:''' do this efficiently for ''n'' = 1e20 or higher.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Numerics;\n\nnamespace RosettaCode\n{\n    class Program\n    {\n        static void Main()\n        {\n            List<BigInteger> candidates = new List<BigInteger>(new BigInteger[] { 1000, 100000, 10000000, 10000000000, 1000000000000000 });\n            candidates.Add(BigInteger.Parse(\"100000000000000000000\"));\n\n            foreach (BigInteger candidate in candidates)\n            {\n                BigInteger c = candidate - 1;\n                BigInteger answer3 = GetSumOfNumbersDivisibleByN(c, 3);\n                BigInteger answer5 = GetSumOfNumbersDivisibleByN(c, 5);\n                BigInteger answer15 = GetSumOfNumbersDivisibleByN(c, 15);\n\n                Console.WriteLine(\"The sum of numbers divisible by 3 or 5 between 1 and {0} is {1}\", c, answer3 + answer5 - answer15);\n            }\n\n            Console.ReadKey(true);\n        }\n\n        private static BigInteger GetSumOfNumbersDivisibleByN(BigInteger candidate, uint n)\n        {\n            BigInteger largest = candidate;\n            while (largest % n > 0)\n                largest--;\n            BigInteger totalCount = (largest / n);\n            BigInteger pairCount = totalCount / 2;\n            bool unpairedNumberOnFoldLine = (totalCount % 2 == 1);\n            BigInteger pairSum = largest + n;\n            return pairCount * pairSum + (unpairedNumberOnFoldLine ? pairSum / 2 : 0);\n        }\n\n    }\n}\n"}
{"title": "Sum to 100", "language": "C sharp|C#", "task": "Find solutions to the    ''sum to one hundred''    puzzle.\n\n\nAdd (insert) the mathematical\noperators      '''+'''    or    '''-'''      (plus\nor minus)   before any of the digits in the\ndecimal numeric string    '''123456789'''    such that the\nresulting mathematical expression adds up to a\nparticular sum    (in this iconic case,   '''100''').\n\n\nExample:   \n              123 + 4 - 5 + 67 - 89   =   100     \n\nShow all output here.\n\n\n:*   Show all solutions that sum to    '''100''' \n:*   Show the sum that has the maximum   ''number''   of solutions   (from zero to infinity++)\n:*   Show the lowest positive sum that   ''can't''   be expressed   (has no solutions),   using the rules for this task\n:*   Show the ten highest numbers that can be expressed using the rules for this task   (extra credit)\n\n++   (where   ''infinity''   would be a relatively small   123,456,789)\n\n\nAn example of a sum that can't be expressed   (within the rules of this task)   is:   '''5074'''\n(which,   of course,   isn't the lowest positive sum that can't be expressed).\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        // All unique expressions that have a plus sign in front of the 1; calculated in parallel\n        var expressionsPlus = Enumerable.Range(0, (int)Math.Pow(3, 8)).AsParallel().Select(i => new Expression(i, 1));\n        // All unique expressions that have a minus sign in front of the 1; calculated in parallel\n        var expressionsMinus = Enumerable.Range(0, (int)Math.Pow(3, 8)).AsParallel().Select(i => new Expression(i, -1));\n        var expressions = expressionsPlus.Concat(expressionsMinus);\n        var results = new Dictionary<int, List<Expression>>();\n        foreach (var e in expressions)\n        {\n            if (results.Keys.Contains(e.Value))\n                results[e.Value].Add(e);\n            else\n                results[e.Value] = new List<Expression>() { e };\n        }\n        Console.WriteLine(\"Show all solutions that sum to 100\");\n        foreach (Expression e in results[100])\n            Console.WriteLine(\"  \" + e);\n        Console.WriteLine(\"Show the sum that has the maximum number of solutions (from zero to infinity)\");\n        var summary = results.Keys.Select(k => new Tuple<int, int>(k, results[k].Count));\n        var maxSols = summary.Aggregate((a, b) => a.Item2 > b.Item2 ? a : b);\n        Console.WriteLine(\"  The sum \" + maxSols.Item1 + \" has \" + maxSols.Item2 + \" solutions.\");\n        Console.WriteLine(\"Show the lowest positive sum that can't be expressed (has no solutions), using the rules for this task\");\n        var lowestPositive = Enumerable.Range(1, int.MaxValue).First(x => !results.Keys.Contains(x));\n        Console.WriteLine(\"  \" + lowestPositive);\n        Console.WriteLine(\"Show the ten highest numbers that can be expressed using the rules for this task (extra credit)\");\n        var highest = from k in results.Keys\n                      orderby k descending\n                      select k;\n        foreach (var x in highest.Take(10))\n            Console.WriteLine(\"  \" + x);\n    }\n}\npublic enum Operations { Plus, Minus, Join };\npublic class Expression\n{\n    protected Operations[] Gaps;\n    // 123456789 => there are 8 \"gaps\" between each number\n    ///             with 3 possibilities for each gap: plus, minus, or join\n    public int Value; // What this expression sums up to\n    protected int _one;\n    \n    public Expression(int serial, int one)\n    {\n        _one = one;\n        Gaps = new Operations[8];\n        // This represents \"serial\" as a base 3 number, each Gap expression being a base-three digit\n        int divisor = 2187; // == Math.Pow(3,7)\n        int times;\n        for (int i = 0; i < 8; i++)\n        {\n            times = Math.DivRem(serial, divisor, out serial);\n            divisor /= 3;\n            if (times == 0)\n                Gaps[i] = Operations.Join;\n            else if (times == 1)\n                Gaps[i] = Operations.Minus;\n            else\n                Gaps[i] = Operations.Plus;\n        }\n        // go ahead and calculate the value of this expression\n        // because this is going to be done in a parallel thread (save time)\n        Value = Evaluate();\n    }\n    public override string ToString()\n    {\n        string ret = _one.ToString();\n        for (int i = 0; i < 8; i++)\n        {\n            switch (Gaps[i])\n            {\n                case Operations.Plus:\n                    ret += \"+\";\n                    break;\n                case Operations.Minus:\n                    ret += \"-\";\n                    break;\n            }\n            ret += (i + 2);\n        }\n        return ret;\n    }\n    private int Evaluate()\n        /* Calculate what this expression equals */\n    {\n        var numbers = new int[9];\n        int nc = 0;\n        var operations = new List<Operations>();\n        int a = 1;\n        for (int i = 0; i < 8; i++)\n        {\n            if (Gaps[i] == Operations.Join)\n                a = a * 10 + (i + 2);\n            else\n            {\n                if (a > 0)\n                {\n                    if (nc == 0)\n                        a *= _one;\n                    numbers[nc++] = a;\n                    a = i + 2;\n                }\n                operations.Add(Gaps[i]);\n            }\n        }\n        if (nc == 0)\n            a *= _one;\n        numbers[nc++] = a;\n        int ni = 0;\n        int left = numbers[ni++];\n        foreach (var operation in operations)\n        {\n            int right = numbers[ni++];\n            if (operation == Operations.Plus)\n                left = left + right;\n            else\n                left = left - right;\n        }\n        return left;\n    }\n}"}
{"title": "Tarjan", "language": "C sharp|C#", "task": "{{wikipedia|Graph}}\n\n\n\nTarjan's algorithm is an algorithm in graph theory for finding the strongly connected components of a graph. \n\nIt runs in linear time, matching the time bound for alternative methods including Kosaraju's algorithm and the path-based strong component algorithm. \n\nTarjan's Algorithm is named for its discoverer, Robert Tarjan.\n\n\n;References:\n* The article on Wikipedia.\n\nSee also: [[Kosaraju]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\n\nclass Node\n{\n    public int LowLink { get; set; }\n    public int Index { get; set; }\n    public int N { get; }\n\n    public Node(int n)\n    {\n        N = n;\n        Index = -1;\n        LowLink = 0;\n    }\n}\n\nclass Graph\n{\n    public HashSet<Node> V { get; }\n    public Dictionary<Node, HashSet<Node>> Adj { get; }\n\n    /// <summary>\n    /// Tarjan's strongly connected components algorithm\n    /// </summary>\n    public void Tarjan()\n    {\n        var index = 0; // number of nodes\n        var S = new Stack<Node>();\n\n        Action<Node> StrongConnect = null;\n        StrongConnect = (v) =>\n        {\n            // Set the depth index for v to the smallest unused index\n            v.Index = index;\n            v.LowLink = index;\n\n            index++;\n            S.Push(v);\n\n            // Consider successors of v\n            foreach (var w in Adj[v])\n                if (w.Index < 0)\n                {\n                    // Successor w has not yet been visited; recurse on it\n                    StrongConnect(w);\n                    v.LowLink = Math.Min(v.LowLink, w.LowLink);\n                }\n                else if (S.Contains(w))\n                    // Successor w is in stack S and hence in the current SCC\n                    v.LowLink = Math.Min(v.LowLink, w.Index);\n\n            // If v is a root node, pop the stack and generate an SCC\n            if (v.LowLink == v.Index)\n            {\n                Console.Write(\"SCC: \");\n\n                Node w;\n                do\n                {\n                    w = S.Pop();\n                    Console.Write(w.N + \" \");\n                } while (w != v);\n\n                Console.WriteLine();\n            }\n        };\n\n        foreach (var v in V)\n            if (v.Index < 0)\n                StrongConnect(v);\n    }\n}"}
{"title": "Temperature conversion", "language": "C sharp|C#", "task": "There are quite a number of temperature scales. For this task we will concentrate on four of the perhaps best-known ones: \nRankine.\n\nThe Celsius and Kelvin scales have the same magnitude, but different null points.\n \n: 0 degrees Celsius corresponds to 273.15 kelvin.\n: 0 kelvin is absolute zero.\n\nThe Fahrenheit and Rankine scales also have the same magnitude, but different null points.\n\n: 0 degrees Fahrenheit corresponds to 459.67 degrees Rankine.\n: 0 degrees Rankine is absolute zero.\n\nThe Celsius/Kelvin and Fahrenheit/Rankine scales have a ratio of 5 : 9.\n\n\n;Task\nWrite code that accepts a value of kelvin, converts it to values of the three other scales, and prints the result. \n\n\n;Example:\n\nK  21.00\n\nC  -252.15\n\nF  -421.87\n\nR  37.80\n\n\n", "solution": "using System;\n\nnamespace TemperatureConversion\n{\n    class Program\n    {\n        static Func<double, double> ConvertKelvinToFahrenheit = x => (x * 1.8) - 459.67;\n        static Func<double, double> ConvertKelvinToRankine = x => x * 1.8;\n        static Func<double, double> ConvertKelvinToCelsius = x => x = 273.13;\n\n        static void Main(string[] args)\n        {\n            Console.Write(\"Enter a Kelvin Temperature: \");\n            string inputVal = Console.ReadLine();\n            double kelvinTemp = 0f;\n\n            if (double.TryParse(inputVal, out kelvinTemp))\n            {\n                Console.WriteLine(string.Format(\"Kelvin: {0}\", kelvinTemp));\n                Console.WriteLine(string.Format(\"Fahrenheit: {0}\", ConvertKelvinToFahrenheit(kelvinTemp)));\n                Console.WriteLine(string.Format(\"Rankine: {0}\", ConvertKelvinToRankine(kelvinTemp)));\n                Console.WriteLine(string.Format(\"Celsius: {0}\", ConvertKelvinToCelsius(kelvinTemp)));\n                Console.ReadKey();\n            }\n            else\n            {\n                Console.WriteLine(\"Invalid input value: \" + inputVal);\n            }\n        }\n    }\n}"}
{"title": "Test integerness", "language": "C sharp|C#", "task": "{| class=\"wikitable\"\n|-\n! colspan=2 | Input\n! colspan=2 | Output\n! rowspan=2 | Comment\n|-\n! Type\n! Value\n! exact\n! tolerance = 0.00001\n|-\n| rowspan=3 | decimal\n| 25.000000\n| colspan=2 | true\n| \n|-\n| 24.999999\n| false\n| true\n| \n|-\n| 25.000100\n| colspan=2 | false\n| \n|-\n| rowspan=4 | floating-point\n| -2.1e120\n| colspan=2 | true\n| This one is tricky, because in most languages it is too large to fit into a native integer type.It is, nonetheless, mathematically an integer, and your code should identify it as such.\n|-\n| -5e-2\n| colspan=2 | false\n| \n|-\n| NaN\n| colspan=2 | false\n| \n|-\n| Inf\n| colspan=2 | false\n| This one is debatable. If your code considers it an integer, that's okay too.\n|-\n| rowspan=2 | complex\n| 5.0+0.0i\n| colspan=2 | true\n| \n|-\n| 5-5i\n| colspan=2 | false\n| \n|}\n\n(The types and notations shown in these tables are merely examples - you should use the native data types and number literals of your programming language and standard library. Use a different set of test-cases, if this one doesn't demonstrate all relevant behavior.)\n\n\n", "solution": "namespace Test_integerness\n{\n\tclass Program\n\t{\n\t\tpublic static void Main(string[] args)\n\t\t{\n\t\t\tConsole.Clear();\n\t\t\tConsole.WriteLine();\n\t\t\tConsole.WriteLine(\" ***************************************************\");\n\t\t\tConsole.WriteLine(\" *                                                 *\");\n\t\t\tConsole.WriteLine(\" *              Integerness test                   *\");\n\t\t\tConsole.WriteLine(\" *                                                 *\");\n\t\t\tConsole.WriteLine(\" ***************************************************\");\n\t\t\tConsole.WriteLine();\n\t\t\t\n\t\t\tConsoleKeyInfo key = new ConsoleKeyInfo('Y',ConsoleKey.Y,true,true,true);\n\t\t\t\n\t\t\twhile(key.Key == ConsoleKey.Y)\n\t\t\t{\n\t\t\t\t// Get number value from keyboard\n\t\t\t\tConsole.Write(\" Enter number value : \");\n\t\t\t\t\n\t\t\t\tstring LINE = Console.ReadLine();\n\t\t\t\t\n\t\t\t\t// Get tolerance value from keyboard\n\t\t\t\tConsole.Write(\" Enter tolerance value : \");\n\t\t\t\t\n\t\t\t\tdouble TOLERANCE = double.Parse(Console.ReadLine());\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t// Resolve entered number format and set NUMBER value\n\t\t\t\tdouble NUMBER = 0;\n\t\t\t\t\n\t\t\t\tstring [] N;\n\t\t\t\t\n\t\t\t\t// Real number value\n\t\t\t\tif(!double.TryParse(LINE, out NUMBER))\n\t\t\t\t{\n\t\t\t\t\t// Rational number value\n\t\t\t\t\tif(LINE.Contains(\"/\"))\n\t\t\t\t\t{\n\t\t\t\t\t\tN = LINE.Split('/');\n\t\t\t\t\t\t\n\t\t\t\t\t\tNUMBER = double.Parse(N[0]) / double.Parse(N[1]);\n\t\t\t\t\t}\n\t\t\t\t\t// Inf value\n\t\t\t\t\telse if(LINE.ToUpper().Contains(\"INF\"))\n\t\t\t\t\t{\n\t\t\t\t\t\tNUMBER = double.PositiveInfinity;\n\t\t\t\t\t}\n\t\t\t\t\t// Complex value\n\t\t\t\t\telse if(LINE.ToUpper().Contains(\"I\"))\n\t\t\t\t\t{\n\t\t\t\t\t\t// Delete letter i\n\t\t\t\t\t\tLINE = LINE.ToUpper().Replace(\"I\",\"\");\n\t\t\t\t\t\t\n\t\t\t\t\t\tstring r = string.Empty; // real part\n\t\t\t\t\t\tstring i = string.Empty; // imaginary part\n\t\t\t\t\t\t\n\t\t\t\t\t\tint s = 1; // sign offset\n\t\t\t\t\t\t\n\t\t\t\t\t\t// Get sign\n\t\t\t\t\t\tif(LINE[0]=='+' || LINE[0]=='-')\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tr+=LINE[0].ToString();\n\t\t\t\t\t\t\tLINE = LINE.Remove(0,1);\n\t\t\t\t\t\t\ts--;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Get real part\n\t\t\t\t\t\tforeach (char element in LINE) \n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif(element!='+' && element!='-')\n\t\t\t\t\t\t\t\tr+=element.ToString();\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// get imaginary part\n\t\t\t\t\t\ti = LINE.Substring(LINE.Length-(r.Length+s));\n\t\t\t\t\t\t\n\t\t\t\t\t\tNUMBER = double.Parse(i);\n\t\t\t\t\t\tif(NUMBER==0)\n\t\t\t\t\t\t\tNUMBER = double.Parse(r);\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tNUMBER = double.NaN;\n\t\t\t\t\t\t\n\t\t\t\t\t}\n\t\t\t\t\t// NaN value\n\t\t\t\t\telse\n\t\t\t\t\t\tNUMBER = double.NaN;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t// Test\n\t\t\t\tbool IS_INTEGER = false;\n\t\t\t\tbool IS_INTEGER_T = false;\n\t\t\t\t\n\t\t\t\tif(double.IsNaN(NUMBER))\n\t\t\t\t\tIS_INTEGER=false;\n\t\t\t\t\n\t\t\t\telse if(Math.Round(NUMBER,0).ToString() == NUMBER.ToString())\n\t\t\t\t\tIS_INTEGER = true;\n\t\t\t\t\n\t\t\t\telse if((decimal)TOLERANCE >= (decimal)Math.Abs( (decimal)Math.Round(NUMBER,0) - (decimal)NUMBER ))\n\t\t\t\t\tIS_INTEGER_T = true;\n\n\t\t\t\t\n\t\t\t\t\n\t\t\t\tif(IS_INTEGER)\n\t\t\t\t\tConsole.WriteLine(\" Is exact integer \" + IS_INTEGER);\n\t\t\t\t\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tConsole.WriteLine( \" Is exact integer \" + IS_INTEGER );\n\t\t\t\t\tConsole.WriteLine( \" Is integer with tolerance \" + IS_INTEGER_T );\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t\n\t\t\t\tConsole.WriteLine();\n\t\t\t\tConsole.Write(\" Another test < Y /N > . . . \");\n\t\t\t\tkey  = Console.ReadKey(true);\n\t\t\t\tConsole.WriteLine();\n\t\t\t\tConsole.WriteLine();\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t}\n}\n\n"}
{"title": "The Name Game", "language": "C sharp|C# from Java", "task": "Write a program that accepts a name as input and outputs the lyrics to the Shirley Ellis song \"The Name Game\".\n\n\nThe regular verse\n\nUnless your name begins with a vowel (A, E, I, O, U), 'B', 'F' or 'M' you don't have to care about special rules.\nThe verse for the name 'Gary' would be like this:\n\n    Gary, Gary, bo-bary\n    Banana-fana fo-fary\n    Fee-fi-mo-mary\n    Gary! \n\nAt the end of every line, the name gets repeated without the first letter: Gary becomes ary\nIf we take (X) as the full name (Gary) and (Y) as the name without the first letter (ary) the verse would look like this:\n\n    (X), (X), bo-b(Y)\n    Banana-fana fo-f(Y)\n    Fee-fi-mo-m(Y)\n    (X)! \n\nVowel as first letter of the name\n\nIf you have a vowel as the first letter of your name (e.g. Earl) you do not truncate the name.\nThe verse looks like this:\n\n    Earl, Earl, bo-bearl\n    Banana-fana fo-fearl\n    Fee-fi-mo-mearl\n    Earl! \n\n'B', 'F' or 'M' as first letter of the name\n\nIn case of a 'B', an 'F' or an 'M' (e.g. Billy, Felix, Mary) there is a special rule.\nThe line which would 'rebuild' the name (e.g. bo-billy) is sung without the first letter of the name.\nThe verse for the name Billy looks like this:\n\n    Billy, Billy, bo-illy\n    Banana-fana fo-filly\n    Fee-fi-mo-milly\n    Billy! \n\nFor the name 'Felix', this would be right:\n\n    Felix, Felix, bo-belix\n    Banana-fana fo-elix\n    Fee-fi-mo-melix\n    Felix!\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Text;\n\nnamespace TheNameGame {\n    class Program {\n        static void PrintVerse(string name) {\n            StringBuilder sb = new StringBuilder(name.ToLower());\n            sb[0] = Char.ToUpper(sb[0]);\n            string x = sb.ToString();\n            string y = \"AEIOU\".IndexOf(x[0]) > -1 ? x.ToLower() : x.Substring(1);\n            string b = \"b\" + y;\n            string f = \"f\" + y;\n            string m = \"m\" + y;\n            switch (x[0]) {\n                case 'B':\n                    b = y;\n                    break;\n                case 'F':\n                    f = y;\n                    break;\n                case 'M':\n                    m = y;\n                    break;\n            }\n            Console.WriteLine(\"{0}, {0}, bo-{1}\", x, b);\n            Console.WriteLine(\"Banana-fana fo-{0}\", f);\n            Console.WriteLine(\"Fee-fi-mo-{0}\", m);\n            Console.WriteLine(\"{0}!\", x);\n            Console.WriteLine();\n        }\n\n        static void Main(string[] args) {\n            List<string> nameList = new List<string>() { \"Gary\", \"Earl\", \"Billy\", \"Felix\", \"Mary\", \"Steve\" };\n            nameList.ForEach(PrintVerse);\n        }\n    }\n}"}
{"title": "The Twelve Days of Christmas", "language": "C sharp|C#", "task": "Write a program that outputs the lyrics of the Christmas carol ''The Twelve Days of Christmas''. \nThe lyrics can be found here.  \n\n(You must reproduce the words in the correct order, but case, format, and punctuation are left to your discretion.)\n\n\n\n", "solution": "using System;\n\npublic class TwelveDaysOfChristmas {\n\n    public static void Main() {\n\n        string[] days = new string[12] {\n            \"first\", \"second\", \"third\", \"fourth\", \"fifth\", \"sixth\", \"seventh\", \"eighth\", \"ninth\",\n            \"tenth\", \"eleventh\", \"twelfth\",\n        };\n\n        string[] gifts = new string[12] {\n            \"A partridge in a pear tree\",\n            \"Two turtle doves\",\n            \"Three french hens\",\n            \"Four calling birds\",\n            \"Five golden rings\",\n            \"Six geese a-laying\",\n            \"Seven swans a-swimming\",\n            \"Eight maids a-milking\",\n            \"Nine ladies dancing\",\n            \"Ten lords a-leaping\",\n            \"Eleven pipers piping\",\n            \"Twelve drummers drumming\"\n        };\n\n        for ( int i = 0; i < 12; i++ ) {\n\n            Console.WriteLine(\"On the \" + days[i] + \" day of Christmas, my true love gave to me\");\n\n            int j = i + 1;\n            while ( j-- > 0 )\n                Console.WriteLine(gifts[j]);\n\n            Console.WriteLine();\n\n            if ( i == 0 )\n                gifts[0] = \"And a partridge in a pear tree\";\n        }\n\n    }\n\n}"}
{"title": "Thue-Morse", "language": "C sharp|C# from Java", "task": "Create a Thue-Morse sequence.\n\n\n;See also\n*   YouTube entry: The Fairest Sharing Sequence Ever\n*   YouTube entry: Math and OCD - My story with the Thue-Morse sequence\n*   Task: [[Fairshare between two and more]]\n\n", "solution": "using System;\nusing System.Text;\n\nnamespace ThueMorse\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            Sequence(6);\n        }\n\n        public static void Sequence(int steps)\n        {\n            var sb1 = new StringBuilder(\"0\");\n            var sb2 = new StringBuilder(\"1\");\n            for (int i = 0; i < steps; i++)\n            {\n                var tmp = sb1.ToString();\n                sb1.Append(sb2);\n                sb2.Append(tmp);\n            }\n            Console.WriteLine(sb1);\n            Console.ReadLine();\n        }\n    }\n}"}
{"title": "Tonelli-Shanks algorithm", "language": "C sharp|C# from Java", "task": "{{wikipedia}}\n\n\nIn computational number theory, the Tonelli-Shanks algorithm is a technique for solving for '''x''' in a congruence of the form:\n\n:: x2  n (mod p)\n\nwhere '''n''' is an integer which is a quadratic residue (mod p), '''p''' is an odd prime, and '''x,n  Fp''' where Fp = {0, 1, ..., p - 1}.\n\nIt is used in cryptography techniques.\n\n\nTo apply the algorithm, we need the Legendre symbol:\n\nThe Legendre symbol '''(a | p)''' denotes the value of a(p-1)/2 (mod p).\n* '''(a | p)  1'''    if '''a''' is a square (mod p)\n* '''(a | p)  -1'''    if '''a''' is not a square (mod p)\n* '''(a | p)  0'''    if '''a'''  0 (mod p) \n\n\n;Algorithm pseudo-code:\n\nAll  are taken to mean (mod p) unless stated otherwise.\n\n* Input: '''p''' an odd prime, and an integer '''n''' .\n* Step 0: Check that '''n''' is indeed a square: (n | p) must be  1 .\n* Step 1: By factoring out powers of 2 from p - 1, find '''q''' and '''s''' such that p - 1 = q2s with '''q''' odd .\n** If p  3 (mod 4) (i.e. s = 1), output the two solutions r  +- n(p+1)/4 .\n* Step 2: Select a non-square '''z''' such that (z | p)  -1 and set c   zq .\n* Step 3: Set r  n(q+1)/2, t  nq, m = s .\n* Step 4: Loop the following:\n** If t  1, output '''r''' and '''p - r''' .\n** Otherwise find, by repeated squaring, the lowest '''i''', 0 < i < m , such that t2i  1 .\n** Let b  c2(m - i - 1), and set r  rb, t  tb2, c  b2 and m = i .\n\n\n\n;Task:\nImplement the above algorithm. \n\nFind solutions (if any) for \n* n = 10 p = 13\n* n = 56 p = 101\n* n = 1030 p = 10009\n* n = 1032 p = 10009\n* n = 44402 p = 100049  \n\n;Extra credit:\n* n  =    665820697     p  =   1000000009      \n* n  =   881398088036     p   =  1000000000039    \n* n  =  41660815127637347468140745042827704103445750172002   p  = 10^50 + 577   \t\n\n\n;See also:\n* [[Modular exponentiation]]\n* [[Cipolla's algorithm]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Numerics;\n\nnamespace TonelliShanks {\n    class Solution {\n        private readonly BigInteger root1, root2;\n        private readonly bool exists;\n\n        public Solution(BigInteger root1, BigInteger root2, bool exists) {\n            this.root1 = root1;\n            this.root2 = root2;\n            this.exists = exists;\n        }\n\n        public BigInteger Root1() {\n            return root1;\n        }\n\n        public BigInteger Root2() {\n            return root2;\n        }\n\n        public bool Exists() {\n            return exists;\n        }\n    }\n\n    class Program {\n        static Solution Ts(BigInteger n, BigInteger p) {\n            if (BigInteger.ModPow(n, (p - 1) / 2, p) != 1) {\n                return new Solution(0, 0, false);\n            }\n\n            BigInteger q = p - 1;\n            BigInteger ss = 0;\n            while ((q & 1) == 0) {\n                ss = ss + 1;\n                q = q >> 1;\n            }\n\n            if (ss == 1) {\n                BigInteger r1 = BigInteger.ModPow(n, (p + 1) / 4, p);\n                return new Solution(r1, p - r1, true);\n            }\n\n            BigInteger z = 2;\n            while (BigInteger.ModPow(z, (p - 1) / 2, p) != p - 1) {\n                z = z + 1;\n            }\n            BigInteger c = BigInteger.ModPow(z, q, p);\n            BigInteger r = BigInteger.ModPow(n, (q + 1) / 2, p);\n            BigInteger t = BigInteger.ModPow(n, q, p);\n            BigInteger m = ss;\n\n            while (true) {\n                if (t == 1) {\n                    return new Solution(r, p - r, true);\n                }\n                BigInteger i = 0;\n                BigInteger zz = t;\n                while (zz != 1 && i < (m - 1)) {\n                    zz = zz * zz % p;\n                    i = i + 1;\n                }\n                BigInteger b = c;\n                BigInteger e = m - i - 1;\n                while (e > 0) {\n                    b = b * b % p;\n                    e = e - 1;\n                }\n                r = r * b % p;\n                c = b * b % p;\n                t = t * c % p;\n                m = i;\n            }\n        }\n\n        static void Main(string[] args) {\n            List<Tuple<long, long>> pairs = new List<Tuple<long, long>>() {\n                new Tuple<long, long>(10, 13),\n                new Tuple<long, long>(56, 101),\n                new Tuple<long, long>(1030, 10009),\n                new Tuple<long, long>(1032, 10009),\n                new Tuple<long, long>(44402, 100049),\n                new Tuple<long, long>(665820697, 1000000009),\n                new Tuple<long, long>(881398088036, 1000000000039),\n            };\n\n            foreach (var pair in pairs) {\n                Solution sol = Ts(pair.Item1, pair.Item2);\n                Console.WriteLine(\"n = {0}\", pair.Item1);\n                Console.WriteLine(\"p = {0}\", pair.Item2);\n                if (sol.Exists()) {\n                    Console.WriteLine(\"root1 = {0}\", sol.Root1());\n                    Console.WriteLine(\"root2 = {0}\", sol.Root2());\n                } else {\n                    Console.WriteLine(\"No solution exists\");\n                }\n                Console.WriteLine();\n            }\n\n            BigInteger bn = BigInteger.Parse(\"41660815127637347468140745042827704103445750172002\");\n            BigInteger bp = BigInteger.Pow(10, 50) + 577;\n            Solution bsol = Ts(bn, bp);\n            Console.WriteLine(\"n = {0}\", bn);\n            Console.WriteLine(\"p = {0}\", bp);\n            if (bsol.Exists()) {\n                Console.WriteLine(\"root1 = {0}\", bsol.Root1());\n                Console.WriteLine(\"root2 = {0}\", bsol.Root2());\n            } else {\n                Console.WriteLine(\"No solution exists\");\n            }\n        }\n    }\n}"}
{"title": "Top rank per group", "language": "C sharp|C#", "task": "Find the top   ''N''   salaries in each department,   where   ''N''   is provided as a parameter.\n\nUse this data as a formatted internal data structure (adapt it to your language-native idioms, rather than parse at runtime), or identify your external data source:\n\nEmployee Name,Employee ID,Salary,Department\nTyler Bennett,E10297,32000,D101\nJohn Rappl,E21437,47000,D050\nGeorge Woltman,E00127,53500,D101\nAdam Smith,E63535,18000,D202\nClaire Buckman,E39876,27800,D202\nDavid McClellan,E04242,41500,D101\nRich Holcomb,E01234,49500,D202\nNathan Adams,E41298,21900,D050\nRichard Potter,E43128,15900,D101\nDavid Motsinger,E27002,19250,D202\nTim Sampair,E03033,27000,D101\nKim Arlich,E10001,57000,D190\nTimothy Grove,E16398,29900,D190\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\npublic class Program\n{\n    class Employee\n    {\n        public Employee(string name, string id, int salary, string department)\n        {\n            Name = name;\n            Id = id;\n            Salary = salary;\n            Department = department;\n        }\n\n        public string Name { get; private set; }\n        public string Id { get; private set; }\n        public int Salary { get; private set; }\n        public string Department { get; private set; }\n\n        public override string ToString()\n        {\n            return String.Format(\"{0, -25}\\t{1}\\t{2}\", Name, Id, Salary);\n        }\n    }\n\n    private static void Main(string[] args)\n    {\n        var employees = new List<Employee>\n                        {\n                            new Employee(\"Tyler Bennett\", \"E10297\", 32000, \"D101\"),\n                            new Employee(\"John Rappl\", \"E21437\", 47000, \"D050\"),\n                            new Employee(\"George Woltman\", \"E21437\", 53500, \"D101\"),\n                            new Employee(\"Adam Smith\", \"E21437\", 18000, \"D202\"),\n                            new Employee(\"Claire Buckman\", \"E39876\", 27800, \"D202\"),\n                            new Employee(\"David McClellan\", \"E04242\", 41500, \"D101\"),\n                            new Employee(\"Rich Holcomb\", \"E01234\", 49500, \"D202\"),\n                            new Employee(\"Nathan Adams\", \"E41298\", 21900, \"D050\"),\n                            new Employee(\"Richard Potter\", \"E43128\", 15900, \"D101\"),\n                            new Employee(\"David Motsinger\", \"E27002\", 19250, \"D202\"),\n                            new Employee(\"Tim Sampair\", \"E03033\", 27000, \"D101\"),\n                            new Employee(\"Kim Arlich\", \"E10001\", 57000, \"D190\"),\n                            new Employee(\"Timothy Grove\", \"E16398\", 29900, \"D190\")\n                        };\n\n        DisplayTopNPerDepartment(employees, 2);\n    }\n\n    static void DisplayTopNPerDepartment(IEnumerable<Employee> employees, int n)\n    {\n        var topSalariesByDepartment =\n            from employee in employees\n            group employee by employee.Department\n            into g\n            select new\n                    {\n                        Department = g.Key,\n                        TopEmployeesBySalary = g.OrderByDescending(e => e.Salary).Take(n)\n                    };\n\n        foreach (var x in topSalariesByDepartment)\n        {\n            Console.WriteLine(\"Department: \" + x.Department);\n            foreach (var employee in x.TopEmployeesBySalary)\n                Console.WriteLine(employee);\n            Console.WriteLine(\"----------------------------\");\n        }\n    }\n}"}
{"title": "Truncate a file", "language": "C sharp", "task": "Truncate a file to a specific length.   This should be implemented as a routine that takes two parameters: the filename and the required file length (in bytes).\n\n\nTruncation can be achieved using system or library calls intended for such a task, if such methods exist, or by creating a temporary file of a reduced size and renaming it, after first deleting the original file, if no other method is available.   The file may contain non human readable binary data in an unspecified format, so the routine should be \"binary safe\", leaving the contents of the untruncated part of the file unchanged.\n\nIf the specified filename does not exist, or the provided length is not less than the current file length, then the routine should raise an appropriate error condition. \n\nOn some systems, the provided file truncation facilities might not change the file or may extend the file, if the specified length is greater than the current length of the file. \n\nThis task permits the use of such facilities.   However, such behaviour should be noted, or optionally a warning message relating to an non change or increase in file size may be implemented.\n\n", "solution": "using System;\nusing System.IO;\n\nnamespace TruncateFile\n{\n    internal class Program\n    {\n        private static void Main(string[] args)\n        {\n            TruncateFile(args[0], long.Parse(args[1]));\n        }\n\n        private static void TruncateFile(string path, long length)\n        {\n            if (!File.Exists(path))\n                throw new ArgumentException(\"No file found at specified path.\", \"path\");\n\n            using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Write))\n            {\n                if (fileStream.Length < length)\n                    throw new ArgumentOutOfRangeException(\"length\",\n                                                          \"The specified length is greater than that of the file.\");\n\n                fileStream.SetLength(length);\n            }\n        }\n    }\n}"}
{"title": "Truth table", "language": "C sharp 7", "task": "A truth table is a display of the inputs to, and the output of a Boolean function organized as a table where each row gives one combination of input values and the corresponding value of the function.\n\n\n;Task:\n# Input a Boolean function from the user as a string then calculate and print a formatted truth table for the given function. (One can assume that the user input is correct).\n# Print and show output for Boolean functions of two and three input variables, but any program should not be limited to that many variables in the function. \n# Either reverse-polish or infix notation expressions are allowed.\n\n\n;Related tasks:\n*   [[Boolean values]]\n*   [[Ternary logic]]\n\n\n;See also:\n*   Wolfram MathWorld entry on truth tables.\n*   some \"truth table\" examples from Google.\n\n", "solution": "using System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\npublic class TruthTable\n{\n    enum TokenType { Unknown, WhiteSpace, Constant, Operand, Operator, LeftParenthesis, RightParenthesis }\n\n    readonly char trueConstant, falseConstant;\n    readonly IDictionary<char, Operator> operators = new Dictionary<char, Operator>();\n\n    public TruthTable(char falseConstant, char trueConstant)\n    {\n        this.trueConstant = trueConstant;\n        this.falseConstant = falseConstant;\n        Operators = new OperatorCollection(operators);\n    }\n\n    public OperatorCollection Operators { get; }\n\n    public void PrintTruthTable(string expression, bool isPostfix = false)\n    {\n        try {\n            foreach (string line in GetTruthTable(expression, isPostfix)) {\n                Console.WriteLine(line);\n            }\n        } catch (ArgumentException ex) {\n            Console.WriteLine(expression + \"   \" + ex.Message);\n        }\n    }\n\n    public IEnumerable<string> GetTruthTable(string expression, bool isPostfix = false)\n    {\n        if (string.IsNullOrWhiteSpace(expression)) throw new ArgumentException(\"Invalid expression.\");\n        //Maps parameters to an index in BitSet\n        //Makes sure they appear in the truth table in the order they first appear in the expression\n        var parameters = expression\n            .Where(c => TypeOf(c) == TokenType.Operand)\n            .Distinct()\n            .Reverse()\n            .Select((c, i) => (symbol: c, index: i))\n            .ToDictionary(p => p.symbol, p => p.index);\n\n        int count = parameters.Count;\n        if (count > 32) throw new ArgumentException(\"Cannot have more than 32 parameters.\");\n        string header = count == 0 ? expression : string.Join(\" \",\n            parameters.OrderByDescending(p => p.Value).Select(p => p.Key)) + \" \" + expression;\n\n        if (!isPostfix) expression = ConvertToPostfix(expression);\n\n        var values = default(BitSet);\n        var stack = new Stack<char>(expression.Length);\n        for (int loop = 1 << count; loop > 0; loop--) {\n            foreach (char token in expression) stack.Push(token);\n            bool result = Evaluate(stack, values, parameters);\n            if (header != null) {\n                if (stack.Count > 0) throw new ArgumentException(\"Invalid expression.\");\n                yield return header;\n                header = null;\n            }\n            string line = (count == 0 ? \"\" : \" \") + (result ? trueConstant : falseConstant);\n            line = string.Join(\" \", Enumerable.Range(0, count)\n                .Select(i => values[count - i - 1] ? trueConstant : falseConstant)) + line;\n            yield return line;\n            values++;\n        }\n    }\n\n    public string ConvertToPostfix(string infix)\n    {\n        var stack = new Stack<char>();\n        var postfix = new StringBuilder();\n        foreach (char c in infix) {\n            switch (TypeOf(c)) {\n            case TokenType.WhiteSpace:\n                continue;\n            case TokenType.Constant:\n            case TokenType.Operand:\n                postfix.Append(c);\n                break;\n            case TokenType.Operator:\n                int precedence = Precedence(c);\n                while (stack.Count > 0 && Precedence(stack.Peek()) > precedence) {\n                    postfix.Append(stack.Pop());\n                }\n                stack.Push(c);\n                break;\n            case TokenType.LeftParenthesis:\n                stack.Push(c);\n                break;\n            case TokenType.RightParenthesis:\n                char top = default(char);\n                while (stack.Count > 0) {\n                    top = stack.Pop();\n                    if (top == '(') break;\n                    else postfix.Append(top);\n                }\n                if (top != '(') throw new ArgumentException(\"No matching left parenthesis.\");\n                break;\n            default:\n                throw new ArgumentException(\"Invalid character: \" + c);\n            }\n        }\n        while (stack.Count > 0) {\n            char top = stack.Pop();\n            if (top == '(') throw new ArgumentException(\"No matching right parenthesis.\");\n            postfix.Append(top);\n        }\n        return postfix.ToString();\n    }\n\n    private bool Evaluate(Stack<char> expression, BitSet values, IDictionary<char, int> parameters)\n    {\n        if (expression.Count == 0) throw new ArgumentException(\"Invalid expression.\");\n        char c = expression.Pop();\n        TokenType type = TypeOf(c);\n        while (type == TokenType.WhiteSpace) type = TypeOf(c = expression.Pop());\n        switch (type) {\n        case TokenType.Constant:\n            return c == trueConstant;\n        case TokenType.Operand:\n            return values[parameters[c]];\n        case TokenType.Operator:\n            bool right = Evaluate(expression, values, parameters);\n            Operator op = operators[c];\n            if (op.Arity == 1) return op.Function(right, right);\n            bool left = Evaluate(expression, values, parameters);\n            return op.Function(left, right);\n        default:\n            throw new ArgumentException(\"Invalid character: \" + c);\n        }\n    }\n\n    private TokenType TypeOf(char c)\n    {\n        if (char.IsWhiteSpace(c)) return TokenType.WhiteSpace;\n        if (c == '(') return TokenType.LeftParenthesis;\n        if (c == ')') return TokenType.RightParenthesis;\n        if (c == trueConstant || c == falseConstant) return TokenType.Constant;\n        if (operators.ContainsKey(c)) return TokenType.Operator;\n        if (char.IsLetter(c)) return TokenType.Operand;\n        return TokenType.Unknown;\n    }\n\n    private int Precedence(char op) => operators.TryGetValue(op, out var o) ? o.Precedence : int.MinValue;\n}\n\nstruct Operator\n{\n    public Operator(char symbol, int precedence, Func<bool, bool> function) : this(symbol, precedence, 1, (l, r) => function(r)) { }\n\n    public Operator(char symbol, int precedence, Func<bool, bool, bool> function) : this(symbol, precedence, 2, function) { }\n\n    private Operator(char symbol, int precedence, int arity, Func<bool, bool, bool> function) : this()\n    {\n        Symbol = symbol;\n        Precedence = precedence;\n        Arity = arity;\n        Function = function;\n    }\n\n    public char Symbol { get; }\n    public int Precedence { get; }\n    public int Arity { get; }\n    public Func<bool, bool, bool> Function { get; }\n}\n\npublic class OperatorCollection : IEnumerable\n{\n    readonly IDictionary<char, Operator> operators;\n\n    internal OperatorCollection(IDictionary<char, Operator> operators) {\n        this.operators = operators;\n    }\n\n    public void Add(char symbol, int precedence, Func<bool, bool> function)\n        => operators[symbol] = new Operator(symbol, precedence, function);\n    public void Add(char symbol, int precedence, Func<bool, bool, bool> function)\n        => operators[symbol] = new Operator(symbol, precedence, function);\n\n    public void Remove(char symbol) => operators.Remove(symbol);\n\n    IEnumerator IEnumerable.GetEnumerator() => operators.Values.GetEnumerator();\n}\n\nstruct BitSet\n{\n    private int bits;\n\n    private BitSet(int bits) { this.bits = bits; }\n\n    public static BitSet operator ++(BitSet bitSet) => new BitSet(bitSet.bits + 1);\n\n    public bool this[int index] => (bits & (1 << index)) != 0;\n}\n\nclass Program\n{\n    public static void Main() {\n        TruthTable tt = new TruthTable('F', 'T') {\n            Operators = {\n                { '!', 6, r => !r },\n                { '&', 5, (l, r) => l && r },\n                { '^', 4, (l, r) => l ^ r },\n                { '|', 3, (l, r) => l || r }\n            }\n        };\n        //Add a crazy operator:\n        var rng = new Random();\n        tt.Operators.Add('?', 6, r => rng.NextDouble() < 0.5);\n        string[] expressions = {\n            \"!!!T\",\n            \"?T\",\n            \"F & x | T\",\n            \"F & (x | T\",\n            \"F & x | T)\",\n            \"a ! (a & a)\",\n            \"a | (a * a)\",\n            \"a ^ T & (b & !c)\",\n        };\n        foreach (string expression in expressions) {\n            tt.PrintTruthTable(expression);\n            Console.WriteLine();\n        }\n\n        //Define a different language\n        tt = new TruthTable('0', '1') {\n            Operators = {\n                { '-', 6, r => !r },\n                { '^', 5, (l, r) => l && r },\n                { 'v', 3, (l, r) => l || r },\n                { '>', 2, (l, r) => !l || r },\n                { '=', 1, (l, r) => l == r },\n            }\n        };\n        expressions = new[] {\n            \"-X v 0 = X ^ 1\",\n            \"(H > M) ^ (S > H) > (S > M)\"\n        };\n        foreach (string expression in expressions) {\n            tt.PrintTruthTable(expression);\n            Console.WriteLine();\n        }\n    }\n}"}
{"title": "URL decoding", "language": "C sharp", "task": "This task   (the reverse of   [[URL encoding]]   and distinct from   [[URL parser]])   is to provide a function \nor mechanism to convert an URL-encoded string into its original unencoded form.\n\n\n;Test cases:\n*   The encoded string   \"http%3A%2F%2Ffoo%20bar%2F\"   should be reverted to the unencoded form   \"http://foo bar/\".\n\n*   The encoded string   \"google.com/search?q=%60Abdu%27l-Bah%C3%A1\"   should revert to the unencoded form   \"google.com/search?q=`Abdu'l-Baha\".\n\n*   The encoded string   \"%25%32%35\"   should revert to the unencoded form   \"%25\" and '''not''' \"%\".\n\n", "solution": "using System;\n\nnamespace URLEncode\n{\n    internal class Program\n    {\n        private static void Main(string[] args)\n        {\n            Console.WriteLine(Decode(\"http%3A%2F%2Ffoo%20bar%2F\"));\n        }\n\n        private static string Decode(string uri)\n        {\n            return Uri.UnescapeDataString(uri);\n        }\n    }\n}"}
{"title": "URL encoding", "language": "C sharp", "task": "Provide a function or mechanism to convert a provided string into URL encoding representation.\n\nIn URL encoding, special characters, control characters and extended characters \nare converted into a percent symbol followed by a two digit hexadecimal code, \nSo a space character encodes into %20 within the string.\n\nFor the purposes of this task, every character except 0-9, A-Z and a-z requires conversion, so the following characters all require conversion by default:\n\n* ASCII control codes (Character ranges 00-1F hex (0-31 decimal) and 7F (127 decimal).\n* ASCII symbols (Character ranges 32-47 decimal (20-2F hex))\n* ASCII symbols (Character ranges 58-64 decimal (3A-40 hex))\n* ASCII symbols (Character ranges 91-96 decimal (5B-60 hex))\n* ASCII symbols (Character ranges 123-126 decimal (7B-7E hex))\n* Extended characters with character codes of 128 decimal (80 hex) and above.\n\n\n;Example:\nThe string \"http://foo bar/\" would be encoded as \"http%3A%2F%2Ffoo%20bar%2F\".\n\n\n;Variations:\n* Lowercase escapes are legal, as in \"http%3a%2f%2ffoo%20bar%2f\".\n* Special characters have different encodings for different standards:\n** RFC 3986, ''Uniform Resource Identifier (URI): Generic Syntax'', section 2.3, says to preserve \"-._~\".\n** HTML 5, section 4.10.22.5 URL-encoded form data, says to preserve \"-._*\", and to encode space \" \" to \"+\".\n** encodeURI function in Javascript will preserve \"-._~\" (RFC 3986) and \";,/?:@&=+$!*'()#\".\n\n;Options:\nIt is permissible to use an exception string (containing a set of symbols \nthat do not need to be converted). \nHowever, this is an optional feature and is not a requirement of this task.\n\n\n;Related tasks: \n*   [[URL decoding]]\n*   [[URL parser]]\n\n", "solution": "using System;\n\nnamespace URLEncode\n{\n    internal class Program\n    {\n        private static void Main(string[] args)\n        {\n            Console.WriteLine(Encode(\"http://foo bar/\"));\n        }\n\n        private static string Encode(string uri)\n        {\n            return Uri.EscapeDataString(uri);\n        }\n    }\n}"}
{"title": "URL parser", "language": "C sharp|C#", "task": "URLs are strings with a simple syntax:\n   scheme://[username:password@]domain[:port]/path?query_string#fragment_id\n\n\n;Task:\nParse a well-formed URL to retrieve the relevant information:   '''scheme''', '''domain''', '''path''', ...\n\n\nNote:   this task has nothing to do with [[URL encoding]] or [[URL decoding]].\n\n\nAccording to the standards, the characters:\n::::       ! * ' ( ) ; : @ & = + $ , / ? % # [ ]    \nonly need to be percent-encoded   ('''%''')   in case of possible confusion. \n\nAlso note that the '''path''', '''query''' and '''fragment''' are case sensitive, even if the '''scheme''' and '''domain''' are not.\n\nThe way the returned information is provided (set of variables, array, structured, record, object,...) \nis language-dependent and left to the programmer, but the code should be clear enough to reuse.\n\nExtra credit is given for clear error diagnostics.\n\n*   Here is the official standard:     https://tools.ietf.org/html/rfc3986, \n*   and here is a simpler   BNF:     http://www.w3.org/Addressing/URL/5_URI_BNF.html.\n\n\n;Test cases:\nAccording to T. Berners-Lee\n \n'''foo://example.com:8042/over/there?name=ferret#nose'''     should parse into:\n::*   scheme = foo\n::*   domain = example.com\n::*   port = :8042\n::*   path = over/there\n::*   query = name=ferret\n::*   fragment = nose\n\n\n'''urn:example:animal:ferret:nose'''     should parse into:\n::*   scheme = urn\n::*   path = example:animal:ferret:nose\n\n\n'''other URLs that must be parsed include:'''\n:*    jdbc:mysql://test_user:ouupppssss@localhost:3306/sakila?profileSQL=true  \n:*    ftp://ftp.is.co.za/rfc/rfc1808.txt                                      \n:*    http://www.ietf.org/rfc/rfc2396.txt#header1                             \n:*    ldap://[2001:db8::7]/c=GB?objectClass=one&objectClass=two               \n:*    mailto:John.Doe@example.com                                             \n:*    news:comp.infosystems.www.servers.unix                                  \n:*    tel:+1-816-555-1212                                                     \n:*    telnet://192.0.2.16:80/                                                 \n:*    urn:oasis:names:specification:docbook:dtd:xml:4.1.2                     \n\n", "solution": "using System;\n\nnamespace RosettaUrlParse\n{\n    class Program\n    {\n        static void ParseUrl(string url)\n        {\n            var u = new Uri(url);\n            Console.WriteLine(\"URL:         {0}\", u.AbsoluteUri);\n            Console.WriteLine(\"Scheme:      {0}\", u.Scheme);\n            Console.WriteLine(\"Host:        {0}\", u.DnsSafeHost);\n            Console.WriteLine(\"Port:        {0}\", u.Port);\n            Console.WriteLine(\"Path:        {0}\", u.LocalPath);\n            Console.WriteLine(\"Query:       {0}\", u.Query);\n            Console.WriteLine(\"Fragment:    {0}\", u.Fragment);\n            Console.WriteLine();\n        }\n        static void Main(string[] args)\n        {\n            ParseUrl(\"foo://example.com:8042/over/there?name=ferret#nose\");\n            ParseUrl(\"urn:example:animal:ferret:nose\");\n            ParseUrl(\"jdbc:mysql://test_user:ouupppssss@localhost:3306/sakila?profileSQL=true\");\n            ParseUrl(\"ftp://ftp.is.co.za/rfc/rfc1808.txt\");\n            ParseUrl(\"http://www.ietf.org/rfc/rfc2396.txt#header1\");\n            ParseUrl(\"ldap://[2001:db8::7]/c=GB?objectClass?one\");\n            ParseUrl(\"mailto:John.Doe@example.com\");\n            ParseUrl(\"news:comp.infosystems.www.servers.unix\");\n            ParseUrl(\"tel:+1-816-555-1212\");\n            ParseUrl(\"telnet://192.0.2.16:80/\");\n            ParseUrl(\"urn:oasis:names:specification:docbook:dtd:xml:4.1.2\");\n        }\n    }\n}\n"}
{"title": "UTF-8 encode and decode", "language": "C sharp|C#", "task": "As described in Wikipedia, UTF-8 is a popular encoding of (multi-byte) [[Unicode]] code-points into eight-bit octets.\n\nThe goal of this task is to write a encoder that takes a unicode code-point (an integer representing a unicode character) and returns a sequence of 1-4 bytes representing that character in the UTF-8 encoding. \n\nThen you have to write the corresponding decoder that takes a sequence of 1-4 UTF-8 encoded bytes and return the corresponding unicode character.\n\nDemonstrate the functionality of your encoder and decoder on the following five characters:\n\n\nCharacter   Name                                  Unicode    UTF-8 encoding (hex)\n---------------------------------------------------------------------------------\nA           LATIN CAPITAL LETTER A                U+0041     41\no           LATIN SMALL LETTER O WITH DIAERESIS   U+00F6     C3 B6\nZh           CYRILLIC CAPITAL LETTER ZHE           U+0416     D0 96\nEUR           EURO SIGN                             U+20AC     E2 82 AC\n           MUSICAL SYMBOL G CLEF                 U+1D11E    F0 9D 84 9E\n\n\nProvided below is a reference implementation in Common Lisp.\n\n", "solution": "using System;\nusing System.Text;\n\nnamespace Rosetta\n{\n    class Program\n    {\n        static byte[] MyEncoder(int codepoint) => Encoding.UTF8.GetBytes(char.ConvertFromUtf32(codepoint));\n        static string MyDecoder(byte[] utf8bytes) => Encoding.UTF8.GetString(utf8bytes);\n        static void Main(string[] args)\n        {\n            Console.OutputEncoding = Encoding.UTF8;  // makes sure it doesn't print rectangles...\n            foreach (int unicodePoint in new int[] {  0x0041, 0x00F6, 0x0416, 0x20AC, 0x1D11E})\n            {\n                byte[] asUtf8bytes = MyEncoder(unicodePoint);\n                string theCharacter = MyDecoder(asUtf8bytes);\n                Console.WriteLine(\"{0,8} {1,5}     {2,-15}\", unicodePoint.ToString(\"X4\"), theCharacter, BitConverter.ToString(asUtf8bytes));\n            }\n        }\n    }\n}\n/* Output:\n *  0041     A     41\n    00F6     \u00f6     C3-B6\n    0416     \u0416     D0-96\n    20AC     \u20ac     E2-82-AC\n   1D11E     \ud834\udd1e     F0-9D-84-9E */\n"}
{"title": "Unbias a random generator", "language": "C sharp", "task": "Given a weighted one-bit generator of random numbers where the probability of a one occurring, P_1, is not the same as P_0, the probability of a zero occurring, the probability of the occurrence of a one followed by a zero is P_1 x P_0, assuming independence. This is the same as the probability of a zero followed by a one: P_0 x P_1.\n\n;Task details:\n* Use your language's random number generator to create a function/method/subroutine/... '''randN''' that returns a one or a zero, but with one occurring, on average, 1 out of N times, where N is an integer from the range 3 to 6 inclusive.\n* Create a function '''unbiased''' that uses only randN as its source of randomness to become an unbiased generator of random ones and zeroes.\n* For N over its range, generate and show counts of the outputs of randN and unbiased(randN).\n\n\nThe actual unbiasing should be done by generating two numbers at a time from randN and only returning a 1 or 0 if they are different. As long as you always return the first number or always return the second number, the probabilities discussed above should take over the biased probability of randN.\n\nThis task is an implementation of Von Neumann debiasing, first described in a 1951 paper.\n\n", "solution": "using System;\n\nnamespace Unbias\n{\n    internal class Program\n    {\n        private static void Main(string[] args)\n        {\n            // Demonstrate.\n            for (int n = 3; n <= 6; n++)\n            {\n                int biasedZero = 0, biasedOne = 0, unbiasedZero = 0, unbiasedOne = 0;\n                for (int i = 0; i < 100000; i++)\n                {\n                    if (randN(n))\n                        biasedOne++;\n                    else\n                        biasedZero++;\n                    if (Unbiased(n))\n                        unbiasedOne++;\n                    else\n                        unbiasedZero++;\n                }\n\n                Console.WriteLine(\"(N = {0}):\".PadRight(17) + \"# of 0\\t# of 1\\t% of 0\\t% of 1\", n);\n                Console.WriteLine(\"Biased:\".PadRight(15) + \"{0}\\t{1}\\t{2}\\t{3}\",\n                                  biasedZero, biasedOne,\n                                  biasedZero/1000, biasedOne/1000);\n                Console.WriteLine(\"Unbiased:\".PadRight(15) + \"{0}\\t{1}\\t{2}\\t{3}\",\n                                  unbiasedZero, unbiasedOne,\n                                  unbiasedZero/1000, unbiasedOne/1000);\n            }\n        }\n\n        private static bool Unbiased(int n)\n        {\n            bool flip1, flip2;\n\n            /* Flip twice, and check if the values are the same.\n             * If so, flip again. Otherwise, return the value of the first flip. */\n\n            do\n            {\n                flip1 = randN(n);\n                flip2 = randN(n);\n            } while (flip1 == flip2);\n\n            return flip1;\n        }\n\n        private static readonly Random random = new Random();\n\n        private static bool randN(int n)\n        {\n            // Has an 1/n chance of returning 1. Otherwise it returns 0.\n            return random.Next(0, n) == 0;\n        }\n    }\n}"}
{"title": "Unicode strings", "language": "C sharp|C#", "task": "As the world gets smaller each day, internationalization becomes more and more important.   For handling multiple languages, [[Unicode]] is your best friend. \n\nIt is a very capable tool, but also quite complex compared to older single- and double-byte character encodings. \n\nHow well prepared is your programming language for Unicode? \n\n\n;Task:\nDiscuss and demonstrate its unicode awareness and capabilities. \n\n\nSome suggested topics:\n:*   How easy is it to present Unicode strings in source code? \n:*   Can Unicode literals be written directly, or be part of identifiers/keywords/etc?\n:*   How well can the language communicate with the rest of the world? \n:*   Is it good at input/output with Unicode?\n:*   Is it convenient to manipulate Unicode strings in the language?\n:*   How broad/deep does the language support Unicode? \n:*   What encodings (e.g. UTF-8, UTF-16, etc) can be used? \n:*   Does it support normalization?\n\n\n;Note:\nThis task is a bit unusual in that it encourages general discussion rather than clever coding.\n\n\n;See also:\n*   [[Unicode variable names]]\n*   [[Terminal control/Display an extended character]]\n\n", "solution": "In C#, the native string representation is actually determined by the Common Language Runtime. In CLR, the string data type is a sequence of char, and the char data type represents a UTF-16 code unit. The native string representation is essentially UTF-16, except that strings can contain sequences of UTF-16 code units that aren't valid in UTF-16 if the string contains incorrectly-used high and low surrogates.\n\nC# string literals support the \\u escape sequence for 4-digit hexadecimal Unicode code points, \\U for 6-digit code points, and UTF-encoded source code is also supported so that \"Unicode strings\" can be included in the source code as-is.\n\nC# benefits from the extensive support for Unicode in the .NET Base Class Library, including\n* Various UTF encodings\n* String normalization\n* Unicode character database subset\n* Breaking strings into text elements\n\n"}
{"title": "Universal Turing machine", "language": "C sharp", "task": "One of the foundational mathematical constructs behind computer science \nis the universal Turing Machine.  \n\n\n(Alan Turing introduced the idea of such a machine in 1936-1937.)\n\nIndeed one way to definitively prove that a language \nis turing-complete \nis to implement a universal Turing machine in it.\n\n\n;Task:\nSimulate such a machine capable \nof taking the definition of any other Turing machine and executing it. \n \nOf course, you will not have an infinite tape, \nbut you should emulate this as much as is possible.  \n\nThe three permissible actions on the tape are \"left\", \"right\" and \"stay\".\n\nTo test your universal Turing machine (and prove your programming language \nis Turing complete!), you should execute the following two Turing machines \nbased on the following definitions.\n\n\n'''Simple incrementer'''\n* '''States:''' q0, qf\n* '''Initial state:''' q0\n* '''Terminating states:''' qf\n* '''Permissible symbols:''' B, 1\n* '''Blank symbol:''' B\n* '''Rules:'''\n** (q0, 1, 1, right, q0)\n** (q0, B, 1, stay,  qf)\n\n\nThe input for this machine should be a tape of 1 1 1\n\n\n'''Three-state busy beaver'''\n* '''States:''' a, b, c, halt\n* '''Initial state:''' a\n* '''Terminating states:''' halt\n* '''Permissible symbols:''' 0, 1\n* '''Blank symbol:''' 0\n* '''Rules:'''\n** (a, 0, 1, right, b)\n** (a, 1, 1, left,  c)\n** (b, 0, 1, left,  a)\n** (b, 1, 1, right, b)\n** (c, 0, 1, left,  b)\n** (c, 1, 1, stay,  halt)\n\n\nThe input for this machine should be an empty tape.\n\n\n'''Bonus:'''\n\n'''5-state, 2-symbol probable Busy Beaver machine from Wikipedia'''\n* '''States:''' A, B, C, D, E, H\n* '''Initial state:''' A\n* '''Terminating states:''' H\n* '''Permissible symbols:''' 0, 1\n* '''Blank symbol:''' 0\n* '''Rules:'''\n** (A, 0, 1, right, B)\n** (A, 1, 1, left,  C)\n** (B, 0, 1, right, C)\n** (B, 1, 1, right, B)\n** (C, 0, 1, right, D)\n** (C, 1, 0, left,  E)\n** (D, 0, 1, left,  A)\n** (D, 1, 1, left,  D)\n** (E, 0, 1, stay,  H)\n** (E, 1, 0, left,  A)\n\n\nThe input for this machine should be an empty tape.\n\nThis machine runs for more than 47 millions steps.\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics;\nusing System.Linq;\nusing System.Text;\nusing System.Threading;\nusing System.Threading.Tasks;\n\npublic class TuringMachine\n{\n    public static async Task Main() {\n        var fiveStateBusyBeaver = new TuringMachine(\"A\", '0', \"H\").WithTransitions(\n            (\"A\", '0', '1', Right, \"B\"),\n            (\"A\", '1', '1', Left,  \"C\"),\n            (\"B\", '0', '1', Right, \"C\"),\n            (\"B\", '1', '1', Right, \"B\"),\n            (\"C\", '0', '1', Right, \"D\"),\n            (\"C\", '1', '0', Left,  \"E\"),\n            (\"D\", '0', '1', Left,  \"A\"),\n            (\"D\", '1', '1', Left,  \"D\"),\n            (\"E\", '0', '1', Stay,  \"H\"),\n            (\"E\", '1', '0', Left,  \"A\")\n        );\n        var busyBeaverTask = fiveStateBusyBeaver.TimeAsync();\n\n        var incrementer = new TuringMachine(\"q0\", 'B', \"qf\").WithTransitions(\n            (\"q0\", '1', '1', Right, \"q0\"),\n            (\"q0\", 'B', '1', Stay,  \"qf\")\n        )\n        .WithInput(\"111\");\n        foreach (var _ in incrementer.Run()) PrintLine(incrementer);\n        PrintResults(incrementer);\n\n        var threeStateBusyBeaver = new TuringMachine(\"a\", '0', \"halt\").WithTransitions(\n            (\"a\", '0', '1', Right, \"b\"),\n            (\"a\", '1', '1', Left,  \"c\"),\n            (\"b\", '0', '1', Left,  \"a\"),\n            (\"b\", '1', '1', Right, \"b\"),\n            (\"c\", '0', '1', Left,  \"b\"),\n            (\"c\", '1', '1', Stay,  \"halt\")\n        );\n        foreach (var _ in threeStateBusyBeaver.Run()) PrintLine(threeStateBusyBeaver);\n        PrintResults(threeStateBusyBeaver);\n\n        var sorter = new TuringMachine(\"A\", '*', \"X\").WithTransitions(\n            (\"A\", 'a', 'a', Right, \"A\"),\n            (\"A\", 'b', 'B', Right, \"B\"),\n            (\"A\", '*', '*', Left,  \"E\"),\n            (\"B\", 'a', 'a', Right, \"B\"),\n            (\"B\", 'b', 'b', Right, \"B\"),\n            (\"B\", '*', '*', Left,  \"C\"),\n            (\"C\", 'a', 'b', Left,  \"D\"),\n            (\"C\", 'b', 'b', Left,  \"C\"),\n            (\"C\", 'B', 'b', Left,  \"E\"),\n            (\"D\", 'a', 'a', Left,  \"D\"),\n            (\"D\", 'b', 'b', Left,  \"D\"),\n            (\"D\", 'B', 'a', Right, \"A\"),\n            (\"E\", 'a', 'a', Left,  \"E\"),\n            (\"E\", '*', '*', Right, \"X\")\n        )\n        .WithInput(\"babbababaa\");\n        sorter.Run().Last();\n        Console.WriteLine(\"Sorted: \" + sorter.TapeString);\n        PrintResults(sorter);\n\n        sorter.Reset().WithInput(\"bbbababaaabba\");\n        sorter.Run().Last();\n        Console.WriteLine(\"Sorted: \" + sorter.TapeString);\n        PrintResults(sorter);\n\n        Console.WriteLine(await busyBeaverTask);\n        PrintResults(fiveStateBusyBeaver);\n\n        void PrintLine(TuringMachine tm) => Console.WriteLine(tm.TapeString + \"\\tState \" + tm.State);\n\n        void PrintResults(TuringMachine tm) {\n            Console.WriteLine($\"End state: {tm.State} = {(tm.Success ? \"Success\" : \"Failure\")}\");\n            Console.WriteLine(tm.Steps + \" steps\");\n            Console.WriteLine(\"tape length: \" + tm.TapeLength);\n            Console.WriteLine();\n        }\n    }\n\n    public const int Left = -1, Stay = 0, Right = 1;\n    private readonly Tape tape;\n    private readonly string initialState;\n    private readonly HashSet<string> terminatingStates;\n    private Dictionary<(string state, char read), (char write, int move, string toState)> transitions;\n\n    public TuringMachine(string initialState, char blankSymbol, params string[] terminatingStates) {\n        State = this.initialState = initialState;\n        tape = new Tape(blankSymbol);\n        this.terminatingStates = terminatingStates.ToHashSet();\n    }\n\n    public TuringMachine WithTransitions(\n        params (string state, char read, char write, int move, string toState)[] transitions)\n    {\n        this.transitions = transitions.ToDictionary(k => (k.state, k.read), k => (k.write, k.move, k.toState));\n        return this;\n    }\n\n    public TuringMachine Reset() {\n        State = initialState;\n        Steps = 0;\n        tape.Reset();\n        return this;\n    }\n\n    public TuringMachine WithInput(string input) {\n        tape.Input(input);\n        return this;\n    }\n\n    public int Steps { get; private set; }\n    public string State { get; private set; }\n    public bool Success => terminatingStates.Contains(State);\n    public int TapeLength => tape.Length;\n    public string TapeString => tape.ToString();\n\n    public IEnumerable<string> Run() {\n        yield return State;\n        while (Step()) yield return State;\n    }\n\n    public async Task<TimeSpan> TimeAsync(CancellationToken cancel = default) {\n        var chrono = Stopwatch.StartNew();\n        await RunAsync(cancel);\n        chrono.Stop();\n        return chrono.Elapsed;\n    }\n\n    public Task RunAsync(CancellationToken cancel = default)\n        => Task.Run(() => {\n            while (Step()) cancel.ThrowIfCancellationRequested();\n        });\n\n    private bool Step() {\n        if (!transitions.TryGetValue((State, tape.Current), out var action)) return false;\n        tape.Current = action.write;\n        tape.Move(action.move);\n        State = action.toState;\n        Steps++;\n        return true;\n    }\n\n\n    private class Tape\n    {\n        private List<char> forwardTape = new List<char>(), backwardTape = new List<char>();\n        private int head = 0;\n        private char blank;\n\n        public Tape(char blankSymbol) => forwardTape.Add(blank = blankSymbol);\n\n        public void Reset() {\n            backwardTape.Clear();\n            forwardTape.Clear();\n            head = 0;\n            forwardTape.Add(blank);\n        }\n\n        public void Input(string input) {\n            Reset();\n            forwardTape.Clear();\n            forwardTape.AddRange(input);\n        }\n\n        public void Move(int direction) {\n            head += direction;\n            if (head >= 0 && forwardTape.Count <= head) forwardTape.Add(blank);\n            if (head < 0 && backwardTape.Count <= ~head) backwardTape.Add(blank);\n        }\n\n        public char Current {\n            get => head < 0 ? backwardTape[~head] : forwardTape[head];\n            set {\n                if (head < 0) backwardTape[~head] = value;\n                else forwardTape[head] = value;\n            }\n        }\n\n        public int Length => backwardTape.Count + forwardTape.Count;\n\n        public override string ToString() {\n            int h = (head < 0 ? ~head : backwardTape.Count + head) * 2 + 1;\n            var builder = new StringBuilder(\" \", Length * 2 + 1);\n            if (backwardTape.Count > 0) {\n                builder.Append(string.Join(\" \", backwardTape)).Append(\" \");\n                if (head < 0) (builder[h + 1], builder[h - 1]) = ('(', ')');\n                for (int l = 0, r = builder.Length - 1; l < r; l++, r--) (builder[l], builder[r]) = (builder[r], builder[l]);\n            }\n            builder.Append(string.Join(\" \", forwardTape)).Append(\" \");\n            if (head >= 0) (builder[h - 1], builder[h + 1]) = ('(', ')');\n            return builder.ToString();\n        }\n\n    }\n\n}"}
{"title": "Unix/ls", "language": "C sharp|C#", "task": "Write a program that will list everything in the current folder,   similar to:\n:::*   the Unix utility   \"ls\"   [http://man7.org/linux/man-pages/man1/ls.1.html]       or \n:::*   the Windows terminal command   \"DIR\" \n\n\nThe output must be sorted, but printing extended details and producing multi-column output is not required.\n\n\n;Example output\nFor the list of paths:\n\n/foo/bar\n/foo/bar/1\n/foo/bar/2\n/foo/bar/a\n/foo/bar/b\n\n\n\nWhen the program is executed in   `/foo`,   it should print:\n\nbar\n\nand when the program is executed in   `/foo/bar`,   it should print:\n\n1\n2\na\nb\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.IO;\nusing System.Linq;\nusing System.Threading.Tasks;\n\nnamespace Unix_ls\n{\n    public class UnixLS\n    {\n        public static void Main(string[] args)\n        {\n            UnixLS ls = new UnixLS();\n            ls.list(args.Length.Equals(0) ? \".\" : args[0]);\n        }\n\n        private void list(string folder)\n        {\n            foreach (FileSystemInfo fileSystemInfo in new DirectoryInfo(folder).EnumerateFileSystemInfos(\"*\", SearchOption.TopDirectoryOnly))\n            {\n                Console.WriteLine(fileSystemInfo.Name);\n            }\n        }\n    }\n}"}
{"title": "Validate International Securities Identification Number", "language": "C sharp|C#", "task": "An International Securities Identification Number (ISIN) is a unique international identifier for a financial security such as a stock or bond. \n\n\n;Task:\nWrite a function or program that takes a string as input, and checks whether it is a valid ISIN.\n\nIt is only valid if it has the correct format,   ''and''   the embedded checksum is correct.\n\nDemonstrate that your code passes the test-cases listed below.\n\n\n;Details:\nThe format of an ISIN is as follows:\n\n\n\n+------------- a 2-character ISO country code (A-Z)\n| +----------- a 9-character security code (A-Z, 0-9)\n| |        +-- a checksum digit (0-9)\nAU0000XVGZA3\n\n\n\n\nFor this task, you may assume that any 2-character alphabetic sequence is a valid country code.\n\nThe checksum can be validated as follows:\n# '''Replace letters with digits''', by converting each character from base 36 to base 10, e.g. AU0000XVGZA3 -1030000033311635103.\n# '''Perform the Luhn test on this base-10 number.'''There is a separate task for this test: ''[[Luhn test of credit card numbers]]''.You don't have to replicate the implementation of this test here   ---   you can just call the existing function from that task.   (Add a comment stating if you did this.)\n\n\n;Test cases:\n:::: {| class=\"wikitable\"\n! ISIN\n! Validity\n! Comment\n|-\n| US0378331005  || valid || \n|-\n| US0373831005  || not valid || The transposition typo is caught by the checksum constraint.\n|-\n| U50378331005  || not valid || The substitution typo is caught by the format constraint.\n|-\n| US03378331005 || not valid || The duplication typo is caught by the format constraint.\n|-\n| AU0000XVGZA3  || valid || \n|-\n| AU0000VXGZA3  || valid || Unfortunately, not ''all'' transposition typos are caught by the checksum constraint.\n|-\n| FR0000988040  || valid || \n|}\n\n(The comments are just informational.   Your function should simply return a Boolean result.   See [[#Raku]] for a reference solution.)\n\n\nRelated task:\n* [[Luhn test of credit card numbers]]\n\n\n;Also see:\n* Interactive online ISIN validator\n* Wikipedia article: International Securities Identification Number\n\n", "solution": "using System;\nusing System.Linq;\nusing System.Text.RegularExpressions;\n\nnamespace ValidateIsin\n{\n    public static class IsinValidator\n    {\n        public static bool IsValidIsin(string isin) => \n            IsinRegex.IsMatch(isin) && LuhnTest(Digitize(isin));\n\n        private static readonly Regex IsinRegex = \n            new Regex(\"^[A-Z]{2}[A-Z0-9]{9}\\\\d$\", RegexOptions.Compiled);\n\n        private static string Digitize(string isin) =>\n            string.Join(\"\", isin.Select(c => $\"{DigitValue(c)}\"));\n\n        private static bool LuhnTest(string number) => \n            number.Reverse().Select(DigitValue).Select(Summand).Sum() % 10 == 0;\n\n        private static int Summand(int digit, int i) =>\n            digit + (i % 2) * (digit - digit / 5 * 9);\n\n        private static int DigitValue(char c) =>\n            c >= '0' && c <= '9' \n                ? c - '0' \n                : c - 'A' + 10;\n   }\n\t\n   public class Program\n   {\n        public static void Main() \n        {\n            string[] isins = \n            {\n                \"US0378331005\",\n                \"US0373831005\",\n                \"U50378331005\",\n                \"US03378331005\",\n                \"AU0000XVGZA3\",\n                \"AU0000VXGZA3\",\n                \"FR0000988040\"\n            };\n\n            foreach (string isin in isins) {\n                string validOrNot = IsinValidator.IsValidIsin(isin) ? \"valid\" : \"not valid\";\n                Console.WriteLine($\"{isin} is {validOrNot}\");\n            }\n        }\n    }\n}"}
{"title": "Van Eck sequence", "language": "C#|CSharp from C", "task": "The sequence is generated by following this pseudo-code:\n\nA:  The first term is zero.\n    Repeatedly apply:\n        If the last term is *new* to the sequence so far then:\nB:          The next term is zero.\n        Otherwise:\nC:          The next term is how far back this last term occured previously.\n\n\n\n;Example:\nUsing A:\n:0\nUsing B:\n:0 0\nUsing C:\n:0 0 1\nUsing B:\n:0 0 1 0\nUsing C:  (zero last occurred two steps back - before the one)\n:0 0 1 0 2\nUsing B:\n:0 0 1 0 2 0\nUsing C:  (two last occurred two steps back - before the zero)\n:0 0 1 0 2 0 2 2\nUsing C:  (two last occurred one step back)\n:0 0 1 0 2 0 2 2 1\nUsing C:  (one last appeared six steps back)\n:0 0 1 0 2 0 2 2 1 6\n...\n\n\n;Task:\n# Create a function/procedure/method/subroutine/... to generate the Van Eck sequence of numbers.\n# Use it to display here, on this page:\n:# The first ten terms of the sequence.\n:# Terms 991 - to - 1000 of the sequence.\n\n\n;References:\n* Don't Know (the Van Eck Sequence) - Numberphile video.\n* Wikipedia Article: Van Eck's Sequence.\n*  OEIS sequence: A181391.\n\n", "solution": "using System.Linq; class Program { static void Main() {\n    int a, b, c, d, e, f, g; int[] h = new int[g = 1000];\n    for (a = 0, b = 1, c = 2; c < g; a = b, b = c++)\n        for (d = a, e = b - d, f = h[b]; e <= b; e++)\n            if (f == h[d--]) { h[c] = e; break; }\n    void sho(int i) { System.Console.WriteLine(string.Join(\" \",\n        h.Skip(i).Take(10))); } sho(0); sho(990); } }"}
{"title": "Van der Corput sequence", "language": "C sharp", "task": "When counting integers in binary, if you put a (binary) point to the right of the count then the column immediately to the left denotes a digit with a multiplier of 2^0; the digit in the next column to the left has a multiplier of 2^1; and so on.\n\nSo in the following table:\n  0.\n  1.\n 10.\n 11.\n ...\nthe binary number \"10\" is 1 \\times 2^1 + 0 \\times 2^0.\n\nYou can also have binary digits to the right of the \"point\", just as in the decimal number system. In that case, the digit in the place immediately to the right of the point has a weight of 2^{-1}, or 1/2. \nThe weight for the second column to the right of the point is 2^{-2} or 1/4. And so on.\n\nIf you take the integer binary count of the first table, and ''reflect'' the digits about the binary point, you end up with '''the van der Corput sequence of numbers in base 2'''.\n\n  .0\n  .1\n  .01\n  .11\n  ...\n\nThe third member of the sequence, binary 0.01, is therefore 0 \\times 2^{-1} + 1 \\times 2^{-2} or 1/4.\n\n Monte Carlo simulations. \nThis sequence is also a superset of the numbers representable by the \"fraction\" field of an old IEEE floating point standard. In that standard, the \"fraction\" field represented the fractional part of a binary number beginning with \"1.\" e.g. 1.101001101.\n\n'''Hint'''\n\nA ''hint'' at a way to generate members of the sequence is to modify a routine used to change the base of an integer:\n>>> def base10change(n, base):\n\tdigits = []\n\twhile n:\n\t\tn,remainder = divmod(n, base)\n\t\tdigits.insert(0, remainder)\n\treturn digits\n\n>>> base10change(11, 2)\n[1, 0, 1, 1]\nthe above showing that 11 in decimal is 1\\times 2^3 + 0\\times 2^2 + 1\\times 2^1 + 1\\times 2^0.\nReflected this would become .1101 or 1\\times 2^{-1} + 1\\times 2^{-2} + 0\\times 2^{-3} + 1\\times 2^{-4}\n\n\n;Task description:\n* Create a function/method/routine that given ''n'', generates the ''n'''th term of the van der Corput sequence in base 2.\n* Use the function to compute ''and display'' the first ten members of the sequence. (The first member of the sequence is for ''n''=0).\n\n* As a stretch goal/extra credit, compute and show members of the sequence for bases other than 2.\n\n\n\n;See also:\n* The Basic Low Discrepancy Sequences\n* [[Non-decimal radices/Convert]]\n* Van der Corput sequence\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace VanDerCorput\n{\n    /// <summary>\n    /// Computes the Van der Corput sequence for any number base.\n    /// The numbers in the sequence vary from zero to one, including zero but excluding one.\n    /// The sequence possesses low discrepancy.\n    /// Here are the first ten terms for bases 2 to 5:\n    /// \n    /// base 2:  0  1/2  1/4  3/4  1/8  5/8  3/8  7/8  1/16  9/16\n    /// base 3:  0  1/3  2/3  1/9  4/9  7/9  2/9  5/9  8/9  1/27\n    /// base 4:  0  1/4  1/2  3/4  1/16  5/16  9/16  13/16  1/8  3/8\n    /// base 5:  0  1/5  2/5  3/5  4/5  1/25  6/25  11/25  16/25  21/25\n    /// </summary>\n    /// <see cref=\"http://rosettacode.org/wiki/Van_der_Corput_sequence\"/>\n    public class VanDerCorputSequence: IEnumerable<Tuple<long,long>>\n    {\n        /// <summary>\n        /// Number base for the sequence, which must bwe two or more.\n        /// </summary>\n        public int Base { get; private set; }\n\n        /// <summary>\n        /// Maximum number of terms to be returned by iterator.\n        /// </summary>\n        public long Count { get; private set; }\n\n        /// <summary>\n        /// Construct a sequence for the given base.\n        /// </summary>\n        /// <param name=\"iBase\">Number base for the sequence.</param>\n        /// <param name=\"count\">Maximum number of items to be returned by the iterator.</param>\n        public VanDerCorputSequence(int iBase, long count = long.MaxValue) {\n            if (iBase < 2)\n                throw new ArgumentOutOfRangeException(\"iBase\", \"must be two or greater, not the given value of \" + iBase);\n            Base = iBase;\n            Count = count;\n        }\n\n        /// <summary>\n        /// Compute nth term in the Van der Corput sequence for the base specified in the constructor.\n        /// </summary>\n        /// <param name=\"n\">The position in the sequence, which may be zero or any positive number.</param>\n        /// This number is always an integral power of the base.</param>\n        /// <returns>The Van der Corput sequence value expressed as a Tuple containing a numerator and a denominator.</returns>\n        public Tuple<long,long> Compute(long n)\n        {\n            long p = 0, q = 1;\n            long numerator, denominator;\n            while (n != 0)\n            {\n                p = p * Base + (n % Base);\n                q *= Base;\n                n /= Base;\n            }\n            numerator = p;\n            denominator = q;\n            while (p != 0) \n            { \n                n = p; \n                p = q % p; \n                q = n; \n            }\n            numerator /= q;\n            denominator /= q;\n            return new Tuple<long,long>(numerator, denominator);\n        }\n\n        /// <summary>\n        /// Compute nth term in the Van der Corput sequence for the given base.\n        /// </summary>\n        /// <param name=\"iBase\">Base to use for the sequence.</param>\n        /// <param name=\"n\">The position in the sequence, which may be zero or any positive number.</param>\n        /// <returns>The Van der Corput sequence value expressed as a Tuple containing a numerator and a denominator.</returns>\n        public static Tuple<long, long> Compute(int iBase, long n)\n        {\n            var seq = new VanDerCorputSequence(iBase);\n            return seq.Compute(n);\n        }\n\n        /// <summary>\n        /// Iterate over the Van Der Corput sequence.\n        /// The first value in the sequence is always zero, regardless of the base.\n        /// </summary>\n        /// <returns>A tuple whose items are the Van der Corput value given as a numerator and denominator.</returns>\n        public IEnumerator<Tuple<long, long>> GetEnumerator()\n        {\n            long iSequenceIndex = 0L;\n            while (iSequenceIndex < Count)\n            {\n                yield return Compute(iSequenceIndex);\n                iSequenceIndex++;\n            }\n        }\n\n        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()\n        {\n            return GetEnumerator();\n        }\n    }\n\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            TestBasesTwoThroughFive();\n\n            Console.WriteLine(\"Type return to continue...\");\n            Console.ReadLine();\n        }\n\n        static void TestBasesTwoThroughFive()\n        {\n            foreach (var seq in Enumerable.Range(2, 5).Select(x => new VanDerCorputSequence(x, 10))) // Just the first 10 elements of the each sequence\n            {\n                Console.Write(\"base \" + seq.Base + \":\");\n                foreach(var vc in seq) \n                    Console.Write(\" \" + vc.Item1 + \"/\" + vc.Item2);\n                Console.WriteLine();\n            }\n        }\n    }\n}\n\n"}
{"title": "Vector products", "language": "C sharp|C#", "task": "A vector is defined as having three dimensions as being represented by an ordered collection of three numbers:   (X, Y, Z). \n\nIf you imagine a graph with the   '''x'''   and   '''y'''   axis being at right angles to each other and having a third,   '''z'''   axis coming out of the page, then a triplet of numbers,   (X, Y, Z)   would represent a point in the region,   and a vector from the origin to the point.\n\nGiven the vectors:\n         A = (a1,  a2,  a3) \n B = (b1,  b2,  b3) \n C = (c1,  c2,  c3) \nthen the following common vector products are defined:\n* '''The dot product'''       (a scalar quantity)\n::::  A * B = a1b1   +   a2b2   +    a3b3  \n* '''The cross product'''       (a vector quantity)\n::::  A x B = (a2b3   -   a3b2,     a3b1   -   a1b3,     a1b2   -   a2b1)  \n* '''The scalar triple product'''       (a scalar quantity)\n::::  A * (B x C) \n* '''The vector triple product'''       (a vector quantity)\n::::  A x (B x C) \n\n\n;Task:\nGiven the three vectors: \n         a = ( 3,    4,    5)\n         b = ( 4,    3,    5)\n         c = (-5,  -12,  -13)\n# Create a named function/subroutine/method to compute the dot product of two vectors.\n# Create a function to compute the cross product of two vectors.\n# Optionally create a function to compute the scalar triple product of three vectors.\n# Optionally create a function to compute the vector triple product of three vectors.\n# Compute and display: a * b\n# Compute and display: a x b\n# Compute and display: a * (b x c), the scalar triple product.\n# Compute and display: a x (b x c), the vector triple product.\n\n\n;References:\n*   A starting page on Wolfram MathWorld is   {{Wolfram|Vector|Multiplication}}.\n*   Wikipedia   dot product. \n*   Wikipedia   cross product. \n*   Wikipedia   triple product.\n\n\n;Related tasks:\n*   [[Dot product]]\n*   [[Quaternion type]]\n\n", "solution": "using System;\nusing System.Windows.Media.Media3D;\n\nclass VectorProducts\n{\n    static double ScalarTripleProduct(Vector3D a, Vector3D b, Vector3D c)\n    {\n        return Vector3D.DotProduct(a, Vector3D.CrossProduct(b, c));\n    }\n\n    static Vector3D VectorTripleProduct(Vector3D a, Vector3D b, Vector3D c)\n    {\n        return Vector3D.CrossProduct(a, Vector3D.CrossProduct(b, c));\n    }\n\n    static void Main()\n    {\n        var a = new Vector3D(3, 4, 5);\n        var b = new Vector3D(4, 3, 5);\n        var c = new Vector3D(-5, -12, -13);\n\n        Console.WriteLine(Vector3D.DotProduct(a, b));\n        Console.WriteLine(Vector3D.CrossProduct(a, b));\n        Console.WriteLine(ScalarTripleProduct(a, b, c));\n        Console.WriteLine(VectorTripleProduct(a, b, c));\n    }\n}"}
{"title": "Visualize a tree", "language": "C sharp", "task": "A tree structure   (i.e. a rooted, connected acyclic graph)   is often used in programming.  \n\nIt's often helpful to visually examine such a structure. \n\nThere are many ways to represent trees to a reader, such as:\n:::*   indented text   (a la unix  tree  command)\n:::*   nested HTML tables\n:::*   hierarchical GUI widgets\n:::*   2D   or   3D   images\n:::*   etc.\n\n;Task:\nWrite a program to produce a visual representation of some tree.  \n\nThe content of the tree doesn't matter, nor does the output format, the only requirement being that the output is human friendly. \n\nMake do with the vague term \"friendly\" the best you can.\n\n", "solution": "using System;\n\npublic static class VisualizeTree\n{\n    public static void Main() {\n        \"A\".t(\n            \"B0\".t(\n                \"C1\",\n                \"C2\".t(\n                    \"D\".t(\"E1\", \"E2\", \"E3\")),\n                \"C3\".t(\n                    \"F1\",\n                    \"F2\",\n                    \"F3\".t(\"G\"),\n                    \"F4\".t(\"H1\", \"H2\"))),\n            \"B1\".t(\n                \"K1\",\n                \"K2\".t(\n                    \"L1\".t(\"M\"),\n                    \"L2\",\n                    \"L3\"),\n                \"K3\")\n        ).Print();\n    }\n\n    private static Tree t(this string value, params Tree[] children) => new Tree(value, children);\n\n    private static void Print(this Tree tree) => tree.Print(true, \"\");\n\n    private static void Print(this Tree tree, bool last, string prefix) {\n        (string current, string next) = last\n            ? (prefix + \"\u2514\u2500\" + tree.Value, prefix + \"  \")\n            : (prefix + \"\u251c\u2500\" + tree.Value, prefix + \"| \");\n        Console.WriteLine(current[2..]);\n        for (int c = 0; c < tree.Children.Length; c++) {\n            tree.Children[c].Print(c == tree.Children.Length - 1, next);\n        }\n    }\n\n    class Tree\n    {\n        public Tree(string value, params Tree[] children) => (Value, Children) = (value, children);\n        public static implicit operator Tree(string value) => new Tree(value);\n        public string Value { get; }\n        public Tree[] Children { get; }\n    }\n    \n}"}
{"title": "Water collected between towers", "language": "C sharp|C#", "task": "In a two-dimensional world, we begin with any bar-chart (or row of close-packed 'towers', each of unit width), and then it rains, \ncompletely filling all convex enclosures in the chart with water. \n\n                                                        \n9               ##           9               ##    \n8               ##           8               ##    \n7     ##        ##           7     ####    \n6     ##  ##    ##           6     ######    \n5 ##  ##  ##  ####           5 ##########    \n4 ##  ##  ########           4 ############    \n3 ######  ########           3 ##############    \n2 ################  ##       2 ##################\n1 ####################       1 ####################\n                                                        \n\nIn the example above, a bar chart representing the values [5, 3, 7, 2, 6, 4, 5, 9, 1, 2] has filled, collecting 14 units of water.\n\nWrite a function, in your language, from a given array of heights, to the number of water units that can be held in this way, by a corresponding bar chart.\n\nCalculate the number of water units that could be collected by bar charts representing each of the following seven series:\n\n   [[1, 5, 3, 7, 2],\n    [5, 3, 7, 2, 6, 4, 5, 9, 1, 2],\n    [2, 6, 3, 5, 2, 8, 1, 4, 2, 2, 5, 3, 5, 7, 4, 1],\n    [5, 5, 5, 5],\n    [5, 6, 7, 8],\n    [8, 7, 7, 6],\n    [6, 7, 10, 7, 6]]\n\n\nSee, also:\n\n* Four Solutions to a Trivial Problem - a Google Tech Talk by Guy Steele\n* Water collected between towers on Stack Overflow, from which the example above is taken)\n* An interesting Haskell solution, using the Tardis monad, by Phil Freeman in a Github gist.\n\n\n\n", "solution": "class Program\n{\n// Variable names key:\n//   i Iterator (of the tower block array).\n// tba Tower block array.\n// tea Tower elevation array.\n// rht Right hand tower column number (position).\n//  wu Water units (count).\n// bof Blocks on floor (count).\n// col Column number in elevation array (position).\n \n    static void Main(string[] args)\n    {\n        int i = 1; int[][] tba = {new int[] { 1, 5, 3, 7, 2 },\n        new int[] { 5, 3, 7, 2, 6, 4, 5, 9, 1, 2 },\n        new int[] { 2, 6, 3, 5, 2, 8, 1, 4, 2, 2, 5, 3, 5, 7, 4, 1 },\n        new int[] { 5, 5, 5, 5 },  new int[] { 5, 6, 7, 8 },\n        new int[] { 8, 7, 7, 6 },  new int[] { 6, 7, 10, 7, 6 }};\n        foreach (int[] tea in tba)\n        {\n            int rht, wu = 0, bof; do\n            {\n                for (rht = tea.Length - 1; rht >= 0; rht--)\n                    if (tea[rht] > 0) break;\n                if (rht < 0) break;\n                bof = 0; for (int col = 0; col <= rht; col++)\n                {\n                    if (tea[col] > 0) { tea[col] -= 1; bof += 1; }\n                    else if (bof > 0) wu++;\n                }\n                if (bof < 2) break;\n            } while (true);\n            System.Console.WriteLine(string.Format(\"Block {0} {1} water units.\",\n                i++, wu == 0 ? \"does not hold any\" : \"holds \" + wu.ToString()));\n        }\n    }\n}"}
{"title": "Weird numbers", "language": "C sharp|C# from D", "task": "In number theory, a perfect either).\n\nIn other words, the sum of the proper divisors of the number (divisors including 1 but not itself) is greater than the number itself (the number is ''abundant''), but no subset of those divisors sums to the number itself (the number is not ''semiperfect'').\n\nFor example:\n\n* '''12''' is ''not'' a weird number.\n** It is abundant; its proper divisors '''1, 2, 3, 4, 6''' sum to '''16''' (which ''is'' > 12),\n** but it ''is'' semiperfect, e.g.:     '''6 + 4 + 2 == 12'''.\n* '''70''' ''is'' a weird number.\n** It is abundant; its proper divisors '''1, 2, 5, 7, 10, 14, 35''' sum to '''74''' (which ''is'' > 70),\n** and there is no subset of proper divisors that sum to '''70'''.\n\n\n;Task:\nFind and display, here on this page, the first '''25''' weird numbers.\n\n\n;Related tasks:\n:* Abundant, deficient and perfect number classifications\n:* Proper divisors\n\n\n;See also:\n:* OEIS: A006037 weird numbers\n:* Wikipedia: weird number\n:* MathWorld: weird number\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\n\nnamespace WeirdNumbers {\n    class Program {\n        static List<int> Divisors(int n) {\n            List<int> divs = new List<int> { 1 };\n            List<int> divs2 = new List<int>();\n\n            for (int i = 2; i * i <= n; i++) {\n                if (n % i == 0) {\n                    int j = n / i;\n                    divs.Add(i);\n                    if (i != j) {\n                        divs2.Add(j);\n                    }\n                }\n            }\n\n            divs.Reverse();\n            divs2.AddRange(divs);\n            return divs2;\n        }\n\n        static bool Abundant(int n, List<int> divs) {\n            return divs.Sum() > n;\n        }\n\n        static bool Semiperfect(int n, List<int> divs) {\n            if (divs.Count > 0) {\n                var h = divs[0];\n                var t = divs.Skip(1).ToList();\n                if (n < h) {\n                    return Semiperfect(n, t);\n                } else {\n                    return n == h\n                        || Semiperfect(n - h, t)\n                        || Semiperfect(n, t);\n                }\n            } else {\n                return false;\n            }\n        }\n\n        static List<bool> Sieve(int limit) {\n            // false denotes abundant and not semi-perfect.\n            // Only interested in even numbers >= 2\n            bool[] w = new bool[limit];\n            for (int i = 2; i < limit; i += 2) {\n                if (w[i]) continue;\n                var divs = Divisors(i);\n                if (!Abundant(i, divs)) {\n                    w[i] = true;\n                } else if (Semiperfect(i, divs)) {\n                    for (int j = i; j < limit; j += i) {\n                        w[j] = true;\n                    }\n                }\n            }\n            return w.ToList();\n        }\n\n        static void Main() {\n            var w = Sieve(17_000);\n            int count = 0;\n            int max = 25;\n            Console.WriteLine(\"The first 25 weird numbers:\");\n            for (int n = 2; count < max; n += 2) {\n                if (!w[n]) {\n                    Console.Write(\"{0} \", n);\n                    count++;\n                }\n            }\n            Console.WriteLine();\n        }\n    }\n}"}
{"title": "Word frequency", "language": "C sharp|C# from D", "task": "Given a text file and an integer   '''n''',   print/display the   '''n'''   most\ncommon words in the file   (and the number of their occurrences)   in decreasing frequency.\n\n\nFor the purposes of this task:\n*   A word is a sequence of one or more contiguous letters.\n*   You are free to define what a   ''letter''   is. \n*   Underscores, accented letters, apostrophes, hyphens, and other special characters can be handled at your discretion.\n*   You may treat a compound word like   '''well-dressed'''   as either one word or two. \n*   The word   '''it's'''   could also be one or two words as you see fit. \n*   You may also choose not to support non US-ASCII characters. \n*   Assume words will not span multiple lines.\n*   Don't worry about normalization of word spelling differences. \n*   Treat   '''color'''   and   '''colour'''   as two distinct words.\n*   Uppercase letters are considered equivalent to their lowercase counterparts.\n*   Words of equal frequency can be listed in any order.\n*   Feel free to explicitly state the thoughts behind the program decisions.\n\n\nShow example output using Les Miserables from Project Gutenberg as the text file input and display the top   '''10'''   most used words.\n\n\n;History:\nThis task was originally taken from programming pearls from Communications of the ACM June 1986 Volume 29 Number 6\nwhere this problem is solved by Donald Knuth using literate programming and then critiqued by Doug McIlroy,\ndemonstrating solving the problem in a 6 line Unix shell script (provided as an example below).\n\n\n;References:\n*McIlroy's program\n\n\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.IO;\nusing System.Linq;\nusing System.Text.RegularExpressions;\n\nnamespace WordCount {\n    class Program {\n        static void Main(string[] args) {\n            var text = File.ReadAllText(\"135-0.txt\").ToLower();\n\n            var match = Regex.Match(text, \"\\\\w+\");\n            Dictionary<string, int> freq = new Dictionary<string, int>();\n            while (match.Success) {\n                string word = match.Value;\n                if (freq.ContainsKey(word)) {\n                    freq[word]++;\n                } else {\n                    freq.Add(word, 1);\n                }\n\n                match = match.NextMatch();\n            }\n\n            Console.WriteLine(\"Rank  Word  Frequency\");\n            Console.WriteLine(\"====  ====  =========\");\n            int rank = 1;\n            foreach (var elem in freq.OrderByDescending(a => a.Value).Take(10)) {\n                Console.WriteLine(\"{0,2}    {1,-4}    {2,5}\", rank++, elem.Key, elem.Value);\n            }\n        }\n    }\n}"}
{"title": "Word search", "language": "C sharp from Java", "task": "A word search puzzle typically consists of a grid of letters in which words are hidden.\n\nThere are many varieties of word search puzzles. For the task at hand we will use a rectangular grid in which the words may be placed horizontally, vertically, or diagonally. The words may also be spelled backwards.\n\nThe words may overlap but are not allowed to zigzag, or wrap around.\n\n;Task \nCreate a 10 by 10 word search and fill it using words from the unixdict. Use only words that are longer than 2, and contain no non-alphabetic characters.\n\nThe cells not used by the hidden words should contain the message: ''Rosetta Code'', read from left to right, top to bottom. These letters should be somewhat evenly distributed over the grid, not clumped together. The message should be in upper case, the hidden words in lower case. All cells should either contain letters from the hidden words or from the message. \n\nPack a minimum of 25 words into the grid.\n\nPrint the resulting grid and the solutions.\n\n;Example\n\n\n     0  1  2  3  4  5  6  7  8  9\n\n0    n  a  y  r  y  R  e  l  m  f \n1    y  O  r  e  t  s  g  n  a  g \n2    t  n  e  d  i  S  k  y  h  E \n3    n  o  t  n  c  p  c  w  t  T \n4    a  l  s  u  u  n  T  m  a  x \n5    r  o  k  p  a  r  i  s  h  h \n6    a  A  c  f  p  a  e  a  c  C \n7    u  b  u  t  t  t  O  l  u  n \n8    g  y  h  w  a  D  h  p  m  u \n9    m  i  r  p  E  h  o  g  a  n \n\nparish     (3,5)(8,5)   gangster   (9,1)(2,1)\npaucity    (4,6)(4,0)   guaranty   (0,8)(0,1)\nprim       (3,9)(0,9)   huckster   (2,8)(2,1)\nplasm      (7,8)(7,4)   fancy      (3,6)(7,2)\nhogan      (5,9)(9,9)   nolo       (1,2)(1,5)\nunder      (3,4)(3,0)   chatham    (8,6)(8,0)\nate        (4,8)(6,6)   nun        (9,7)(9,9)\nbutt       (1,7)(4,7)   hawk       (9,5)(6,2)\nwhy        (3,8)(1,8)   ryan       (3,0)(0,0)\nfay        (9,0)(7,2)   much       (8,8)(8,5)\ntar        (5,7)(5,5)   elm        (6,0)(8,0)\nmax        (7,4)(9,4)   pup        (5,3)(3,5)\nmph        (8,8)(6,8)\n\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text.RegularExpressions;\n\nnamespace Wordseach\n{\n    static class Program\n    {\n        readonly static int[,] dirs = {{1, 0}, {0, 1}, {1, 1}, {1, -1}, {-1, 0},\n            {0, -1}, {-1, -1}, {-1, 1}};\n\n        class Grid\n        {\n            public char[,] Cells = new char[nRows, nCols];\n            public List<string> Solutions = new List<string>();\n            public int NumAttempts;\n        }\n\n        readonly static int nRows = 10;\n        readonly static int nCols = 10;\n        readonly static int gridSize = nRows * nCols;\n        readonly static int minWords = 25;\n\n        readonly static Random rand = new Random();\n\n        static void Main(string[] args)\n        {\n            PrintResult(CreateWordSearch(ReadWords(\"unixdict.txt\")));\n        }\n\n        private static List<string> ReadWords(string filename)\n        {\n            int maxLen = Math.Max(nRows, nCols);\n\n            return System.IO.File.ReadAllLines(filename)\n                .Select(s => s.Trim().ToLower())\n                .Where(s => Regex.IsMatch(s, \"^[a-z]{3,\" + maxLen + \"}$\"))\n                .ToList();\n        }\n\n        private static Grid CreateWordSearch(List<string> words)\n        {\n            int numAttempts = 0;\n\n            while (++numAttempts < 100)\n            {\n                words.Shuffle();\n\n                var grid = new Grid();\n                int messageLen = PlaceMessage(grid, \"Rosetta Code\");\n                int target = gridSize - messageLen;\n\n                int cellsFilled = 0;\n                foreach (var word in words)\n                {\n                    cellsFilled += TryPlaceWord(grid, word);\n                    if (cellsFilled == target)\n                    {\n                        if (grid.Solutions.Count >= minWords)\n                        {\n                            grid.NumAttempts = numAttempts;\n                            return grid;\n                        }\n                        else break; // grid is full but we didn't pack enough words, start over\n                    }\n                }\n            }\n            return null;\n        }\n\n        private static int TryPlaceWord(Grid grid, string word)\n        {\n            int randDir = rand.Next(dirs.GetLength(0));\n            int randPos = rand.Next(gridSize);\n\n            for (int dir = 0; dir < dirs.GetLength(0); dir++)\n            {\n                dir = (dir + randDir) % dirs.GetLength(0);\n\n                for (int pos = 0; pos < gridSize; pos++)\n                {\n                    pos = (pos + randPos) % gridSize;\n\n                    int lettersPlaced = TryLocation(grid, word, dir, pos);\n                    if (lettersPlaced > 0)\n                        return lettersPlaced;\n                }\n            }\n            return 0;\n        }\n\n        private static int TryLocation(Grid grid, string word, int dir, int pos)\n        {\n            int r = pos / nCols;\n            int c = pos % nCols;\n            int len = word.Length;\n\n            //  check bounds\n            if ((dirs[dir, 0] == 1 && (len + c) > nCols)\n                    || (dirs[dir, 0] == -1 && (len - 1) > c)\n                    || (dirs[dir, 1] == 1 && (len + r) > nRows)\n                    || (dirs[dir, 1] == -1 && (len - 1) > r))\n                return 0;\n\n            int rr, cc, i, overlaps = 0;\n\n            // check cells\n            for (i = 0, rr = r, cc = c; i < len; i++)\n            {\n                if (grid.Cells[rr, cc] != 0 && grid.Cells[rr, cc] != word[i])\n                {\n                    return 0;\n                }\n\n                cc += dirs[dir, 0];\n                rr += dirs[dir, 1];\n            }\n\n            // place\n            for (i = 0, rr = r, cc = c; i < len; i++)\n            {\n                if (grid.Cells[rr, cc] == word[i])\n                    overlaps++;\n                else\n                    grid.Cells[rr, cc] = word[i];\n\n                if (i < len - 1)\n                {\n                    cc += dirs[dir, 0];\n                    rr += dirs[dir, 1];\n                }\n            }\n\n            int lettersPlaced = len - overlaps;\n            if (lettersPlaced > 0)\n            {\n                grid.Solutions.Add($\"{word,-10} ({c},{r})({cc},{rr})\");\n            }\n\n            return lettersPlaced;\n        }\n\n        private static int PlaceMessage(Grid grid, string msg)\n        {\n            msg = Regex.Replace(msg.ToUpper(), \"[^A-Z]\", \"\");\n\n            int messageLen = msg.Length;\n            if (messageLen > 0 && messageLen < gridSize)\n            {\n                int gapSize = gridSize / messageLen;\n\n                for (int i = 0; i < messageLen; i++)\n                {\n                    int pos = i * gapSize + rand.Next(gapSize);\n                    grid.Cells[pos / nCols, pos % nCols] = msg[i];\n                }\n                return messageLen;\n            }\n            return 0;\n        }\n\n        public static void Shuffle<T>(this IList<T> list)\n        {\n            int n = list.Count;\n            while (n > 1)\n            {\n                n--;\n                int k = rand.Next(n + 1);\n                T value = list[k];\n                list[k] = list[n];\n                list[n] = value;\n            }\n        }\n\n        private static void PrintResult(Grid grid)\n        {\n            if (grid == null || grid.NumAttempts == 0)\n            {\n                Console.WriteLine(\"No grid to display\");\n                return;\n            }\n            int size = grid.Solutions.Count;\n\n            Console.WriteLine(\"Attempts: \" + grid.NumAttempts);\n            Console.WriteLine(\"Number of words: \" + size);\n\n            Console.WriteLine(\"\\n     0  1  2  3  4  5  6  7  8  9\");\n            for (int r = 0; r < nRows; r++)\n            {\n                Console.Write(\"\\n{0}   \", r);\n                for (int c = 0; c < nCols; c++)\n                    Console.Write(\" {0} \", grid.Cells[r, c]);\n            }\n\n            Console.WriteLine(\"\\n\");\n\n            for (int i = 0; i < size - 1; i += 2)\n            {\n                Console.WriteLine(\"{0}   {1}\", grid.Solutions[i],\n                        grid.Solutions[i + 1]);\n            }\n            if (size % 2 == 1)\n                Console.WriteLine(grid.Solutions[size - 1]);\n\n            Console.ReadLine();\n        }        \n    }\n}"}
{"title": "Word wrap", "language": "C sharp", "task": "Even today, with proportional fonts and complex layouts, there are still cases where you need to wrap text at a specified column.  \n\n\n;Basic task:\nThe basic task is to wrap a paragraph of text in a simple way in your language.  \n\nIf there is a way to do this that is built-in, trivial, or provided in a standard library, show that.  Otherwise implement the minimum length greedy algorithm from Wikipedia.\n\nShow your routine working on a sample of text at two different wrap columns.\n\n\n;Extra credit:\nWrap text using a more sophisticated algorithm such as the Knuth and Plass TeX algorithm.  \nIf your language provides this, you get easy extra credit, \nbut you ''must reference documentation'' indicating that the algorithm \nis something better than a simple minimum length algorithm.\n\nIf you have both basic and extra credit solutions, show an example where \nthe two algorithms give different results.\n\n\n\n", "solution": "namespace RosettaCode.WordWrap\n{\n    using System;\n    using System.Collections.Generic;\n\n    internal static class Program\n    {\n        private const string LoremIpsum = @\"\nLorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas varius sapien\nvel purus hendrerit vehicula. Integer hendrerit viverra turpis, ac sagittis arcu\npharetra id. Sed dapibus enim non dui posuere sit amet rhoncus tellus\nconsectetur. Proin blandit lacus vitae nibh tincidunt cursus. Cum sociis natoque\npenatibus et magnis dis parturient montes, nascetur ridiculus mus. Nam tincidunt\npurus at tortor tincidunt et aliquam dui gravida. Nulla consectetur sem vel\nfelis vulputate et imperdiet orci pharetra. Nam vel tortor nisi. Sed eget porta\ntortor. Aliquam suscipit lacus vel odio faucibus tempor. Sed ipsum est,\ncondimentum eget eleifend ac, ultricies non dui. Integer tempus, nunc sed\nvenenatis feugiat, augue orci pellentesque risus, nec pretium lacus enim eu\nnibh.\";\n\n        private static void Main()\n        {\n            foreach (var lineWidth in new[] { 72, 80 })\n            {\n                Console.WriteLine(new string('-', lineWidth));\n                Console.WriteLine(Wrap(LoremIpsum, lineWidth));\n            }\n        }\n\n        private static string Wrap(string text, int lineWidth)\n        {\n            return string.Join(string.Empty,\n                               Wrap(\n                                   text.Split(new char[0],\n                                              StringSplitOptions\n                                                  .RemoveEmptyEntries),\n                                   lineWidth));\n        }\n\n        private static IEnumerable<string> Wrap(IEnumerable<string> words,\n                                                int lineWidth)\n        {\n            var currentWidth = 0;\n            foreach (var word in words)\n            {\n                if (currentWidth != 0)\n                {\n                    if (currentWidth + word.Length < lineWidth)\n                    {\n                        currentWidth++;\n                        yield return \" \";\n                    }\n                    else\n                    {\n                        currentWidth = 0;\n                        yield return Environment.NewLine;\n                    }\n                }\n                currentWidth += word.Length;\n                yield return word;\n            }\n        }\n    }\n}"}
{"title": "World Cup group stage", "language": "C sharp", "task": "It's World Cup season (or at least it was when this page was created)! \n\nThe World Cup is an international football/soccer tournament that happens every 4 years.   Countries put their international teams together in the years between tournaments and qualify for the tournament based on their performance in other international games.   Once a team has qualified they are put into a group with 3 other teams. \n\nFor the first part of the World Cup tournament the teams play in \"group stage\" games where each of the four teams in a group plays all three other teams once.   The results of these games determine which teams will move on to the \"knockout stage\" which is a standard single-elimination tournament.   The two teams from each group with the most standings points move on to the knockout stage. \n\nEach game can result in a win for one team and a loss for the other team or it can result in a draw/tie for each team. \n:::*   A win is worth three points.\n:::*   A draw/tie is worth one point. \n:::*   A loss is worth zero points.\n\n\n;Task:\n:*   Generate all possible outcome combinations for the six group stage games.   With three possible outcomes for each game there should be 36 = 729 of them. \n:*   Calculate the standings points for each team with each combination of outcomes. \n:*   Show a histogram (graphical,   ASCII art, or straight counts--whichever is easiest/most fun) of the standings points for all four teams over all possible outcomes.\n\n\nDon't worry about tiebreakers as they can get complicated.   We are basically looking to answer the question \"if a team gets x standings points, where can they expect to end up in the group standings?\".\n\n''Hint: there should be no possible way to end up in second place with less than two points as well as no way to end up in first with less than three.   Oddly enough, there is no way to get 8 points at all.''\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing static System.Console;\nusing static System.Linq.Enumerable;\n\nnamespace WorldCupGroupStage\n{\n    public static class WorldCupGroupStage\n    {\n        static int[][] _histogram;\n\n        static WorldCupGroupStage()\n        {\n            int[] scoring = new[] { 0, 1, 3 };\n\n            _histogram = Repeat<Func<int[]>>(()=>new int[10], 4).Select(f=>f()).ToArray();\n\n            var teamCombos = Range(0, 4).Combinations(2).Select(t2=>t2.ToArray()).ToList();\n\n            foreach (var results in Range(0, 3).CartesianProduct(6))\n            {\n                var points = new int[4]; \n\n                foreach (var (result, teams) in results.Zip(teamCombos, (r, t) => (r, t)))\n                {\n                    points[teams[0]] += scoring[result];\n                    points[teams[1]] += scoring[2 - result];\n                }\n\n                foreach(var (p,i) in points.OrderByDescending(a => a).Select((p,i)=>(p,i)))\n                    _histogram[i][p]++;\n            }\n        }\n      \n       // https://gist.github.com/martinfreedman/139dd0ec7df4737651482241e48b062f\n       \n       static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> seqs) => \n            seqs.Aggregate(Empty<T>().ToSingleton(), (acc, sq) => acc.SelectMany(a => sq.Select(s => a.Append(s))));\n        \n       static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<T> seq, int repeat = 1) => \n            Repeat(seq, repeat).CartesianProduct();\n\n       static IEnumerable<IEnumerable<T>> Combinations<T>(this IEnumerable<T> seq) => \n            seq.Aggregate(Empty<T>().ToSingleton(), (a, b) => a.Concat(a.Select(x => x.Append(b))));\n\n       static IEnumerable<IEnumerable<T>> Combinations<T>(this IEnumerable<T> seq, int numItems) => \n            seq.Combinations().Where(s => s.Count() == numItems);\n\n        private static IEnumerable<T> ToSingleton<T>(this T item) { yield return item; }\n\n        static new string ToString()\n        {\n            var sb = new StringBuilder();\n\n            var range = String.Concat(Range(0, 10).Select(i => $\"{i,-3} \"));\n            sb.AppendLine($\"Points      : {range}\");\n\n            var u = String.Concat(Repeat(\"\u2500\", 40+13));\n            sb.AppendLine($\"{u}\");\n\n            var places = new[] { \"First\", \"Second\", \"Third\", \"Fourth\" };\n            foreach (var row in _histogram.Select((r, i) => (r, i)))\n            {\n                sb.Append($\"{places[row.i],-6} place: \");\n                foreach (var standing in row.r)\n                    sb.Append($\"{standing,-3} \");\n                sb.Append(\"\\n\");\n            }\n\n            return sb.ToString();\n        }\n\n        static void Main(string[] args)\n        {\n            Write(ToString());\n            Read();\n        }\n    }\n}\n"}
{"title": "Write float arrays to a text file", "language": "C sharp|C#", "task": "Write two equal-sized numerical arrays 'x' and 'y' to \na two-column text file named 'filename'.\n\nThe first column of the file contains values from an 'x'-array with a \ngiven 'xprecision', the second -- values from 'y'-array with 'yprecision'.\n\nFor example, considering:\n    x = {1, 2, 3, 1e11};\n    y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}; \n                                                           /* sqrt(x) */\n    xprecision = 3;\n    yprecision = 5;\n\nThe file should look like:\n    1    1\n    2    1.4142\n    3    1.7321\n    1e+011   3.1623e+005\n\nThis task is intended as a subtask for [[Measure relative performance of sorting algorithms implementations]].\n\n", "solution": "using System.IO;\n\nclass Program\n{\n    static void Main(string[] args)\n    {\n        var x = new double[] { 1, 2, 3, 1e11 };\n        var y = new double[] { 1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791 };\n\n        int xprecision = 3;\n        int yprecision = 5;\n\n        string formatString = \"{0:G\" + xprecision + \"}\\t{1:G\" + yprecision + \"}\";\n\n        using (var outf = new StreamWriter(\"FloatArrayColumns.txt\"))\n            for (int i = 0; i < x.Length; i++)\n                outf.WriteLine(formatString, x[i], y[i]);\n    }\n}"}
{"title": "Write language name in 3D ASCII", "language": "C sharp|C#", "task": "Write/display a language's name in '''3D''' ASCII. \n\n\n(We can leave the definition of \"3D ASCII\" fuzzy, \nso long as the result is interesting or amusing, \nnot a cheap hack to satisfy the task.)\n\n\n;Related tasks:\n* draw a sphere\n* draw a cuboid\n* draw a rotating cube\n* draw a Deathstar\n\n", "solution": "using System;\nusing System.Text;\n\nnamespace Language_name_in_3D_ascii\n{\n    public class F5\n    {\n        char[] z = { ' ', ' ', '_', '/', };\n        long[,] f ={\n            {87381,87381,87381,87381,87381,87381,87381,},\n            {349525,375733,742837,742837,375733,349525,349525,},\n            {742741,768853,742837,742837,768853,349525,349525,},\n            {349525,375733,742741,742741,375733,349525,349525,},\n            {349621,375733,742837,742837,375733,349525,349525,},\n            {349525,375637,768949,742741,375733,349525,349525,},\n            {351157,374101,768949,374101,374101,349525,349525,},\n            {349525,375733,742837,742837,375733,349621,351157,},\n            {742741,768853,742837,742837,742837,349525,349525,},\n            {181,85,181,181,181,85,85,},\n            {1461,1365,1461,1461,1461,1461,2901,},\n            {742741,744277,767317,744277,742837,349525,349525,},\n            {181,181,181,181,181,85,85,},\n            {1431655765,3149249365L,3042661813L,3042661813L,3042661813L,1431655765,1431655765,},\n            {349525,768853,742837,742837,742837,349525,349525,},\n            {349525,375637,742837,742837,375637,349525,349525,},\n            {349525,768853,742837,742837,768853,742741,742741,},\n            {349525,375733,742837,742837,375733,349621,349621,},\n            {349525,744373,767317,742741,742741,349525,349525,},\n            {349525,375733,767317,351157,768853,349525,349525,},\n            {374101,768949,374101,374101,351157,349525,349525,},\n            {349525,742837,742837,742837,375733,349525,349525,},\n            {5592405,11883957,11883957,5987157,5616981,5592405,5592405,},\n            {366503875925L,778827027893L,778827027893L,392374737749L,368114513237L,366503875925L,366503875925L,},\n            {349525,742837,375637,742837,742837,349525,349525,},\n            {349525,742837,742837,742837,375733,349621,375637,},\n            {349525,768949,351061,374101,768949,349525,349525,},\n            {375637,742837,768949,742837,742837,349525,349525,},\n            {768853,742837,768853,742837,768853,349525,349525,},\n            {375733,742741,742741,742741,375733,349525,349525,},\n            {192213,185709,185709,185709,192213,87381,87381,},\n            {1817525,1791317,1817429,1791317,1817525,1398101,1398101,},\n            {768949,742741,768853,742741,742741,349525,349525,},\n            {375733,742741,744373,742837,375733,349525,349525,},\n            {742837,742837,768949,742837,742837,349525,349525,},\n            {48053,23381,23381,23381,48053,21845,21845,},\n            {349621,349621,349621,742837,375637,349525,349525,},\n            {742837,744277,767317,744277,742837,349525,349525,},\n            {742741,742741,742741,742741,768949,349525,349525,},\n            {11883957,12278709,11908533,11883957,11883957,5592405,5592405,},\n            {11883957,12277173,11908533,11885493,11883957,5592405,5592405,},\n            {375637,742837,742837,742837,375637,349525,349525,},\n            {768853,742837,768853,742741,742741,349525,349525,},\n            {6010197,11885397,11909973,11885397,6010293,5592405,5592405,},\n            {768853,742837,768853,742837,742837,349525,349525,},\n            {375733,742741,375637,349621,768853,349525,349525,},\n            {12303285,5616981,5616981,5616981,5616981,5592405,5592405,},\n            {742837,742837,742837,742837,375637,349525,349525,},\n            {11883957,11883957,11883957,5987157,5616981,5592405,5592405,},\n            {3042268597L,3042268597L,3042661813L,1532713813,1437971797,1431655765,1431655765,},\n            {11883957,5987157,5616981,5987157,11883957,5592405,5592405,},\n            {11883957,5987157,5616981,5616981,5616981,5592405,5592405,},\n            {12303285,5593941,5616981,5985621,12303285,5592405,5592405,}\n            };\n\n        private F5(string s)\n        {\n            StringBuilder[] o = new StringBuilder[7];\n            for (int i = 0; i < 7; i++) o[i] = new StringBuilder();\n            for (int i = 0, l = s.Length; i < l; i++)\n            {\n                int c = s[i];\n                if (65 <= c && c <= 90) c -= 39;\n                else if (97 <= c && c <= 122) c -= 97;\n                else c = -1;\n                long[] d = new long[7];\n                Buffer.BlockCopy(f, (++c * sizeof(long) * 7), d, 0, 7 * sizeof(long));\n                for (int j = 0; j < 7; j++)\n                {\n                    StringBuilder b = new StringBuilder();\n                    long v = d[j];\n                    while (v > 0)\n                    {\n                        b.Append(z[(int)(v & 3)]);\n                        v >>= 2;\n                    }\n                    char[] charArray = b.ToString().ToCharArray();\n                    Array.Reverse(charArray);\n                    o[j].Append(new string(charArray));\n                }\n            }\n            for (int i = 0; i < 7; i++)\n            {\n                for (int j = 0; j < 7 - i; j++)\n                    System.Console.Write(' ');\n                System.Console.WriteLine(o[i]);\n            }\n        }\n\n        public static void Main(string[] args)\n        {\n            new F5(args.Length > 0 ? args[0] : \"C sharp\");\n        }\n    }\n}"}
{"title": "Write to Windows event log", "language": "C sharp", "task": "Write script status to the Windows Event Log\n\n", "solution": "using System.Diagnostics;\n\nnamespace RC\n{\n  internal class Program\n  {\n    public static void Main()\n    {\n      string sSource  = \"Sample App\";\n      string sLog     = \"Application\";\n      string sEvent   = \"Hello from RC!\";\n\n      if (!EventLog.SourceExists(sSource))\n        EventLog.CreateEventSource(sSource, sLog);\n\n      EventLog.WriteEntry(sSource, sEvent);\n      EventLog.WriteEntry(sSource, sEvent, EventLogEntryType.Information);\n    }\n  }\n}"}
{"title": "Zeckendorf number representation", "language": "C sharp", "task": "Just as numbers can be represented in a positional notation as sums of multiples of the powers of ten (decimal) or two (binary); all the positive integers can be represented as the sum of one or zero times the distinct members of the Fibonacci series.\n\nRecall that the first six distinct Fibonacci numbers are:  1, 2, 3, 5, 8, 13. \n\nThe decimal number eleven can be written as 0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1 or 010100 in positional notation where the columns represent multiplication by a particular member of the sequence. Leading zeroes are dropped so that 11 decimal becomes 10100.\n\n10100 is not the only way to make 11 from the Fibonacci numbers however;  0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1 or 010011 would also represent decimal 11. For a true Zeckendorf number there is the added restriction that ''no two consecutive Fibonacci numbers can be used'' which leads to the former unique solution.\n\n\n;Task:\nGenerate and show here a table of the Zeckendorf number representations of the decimal numbers zero to twenty, in order.  \n\nThe intention in this task to find the Zeckendorf form of an arbitrary integer.  The Zeckendorf form can be iterated by some bit twiddling rather than calculating each value separately but leave that to another separate task. \n\n\n;Also see:\n*   OEIS A014417   for the the sequence of required results.\n*   Brown's Criterion - Numberphile\n\n\n;Related task:\n*   [[Fibonacci sequence]]\n\n", "solution": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Zeckendorf\n{\n    class Program\n    {\n        private static uint Fibonacci(uint n)\n        {\n            if (n < 2)\n            {\n                return n;\n            }\n            else\n            {\n                return Fibonacci(n - 1) + Fibonacci(n - 2);\n            }\n        }\n\n        private static string Zeckendorf(uint num)\n        {\n            IList<uint> fibonacciNumbers = new List<uint>();\n            uint fibPosition = 2;\n\n            uint currentFibonaciNum = Fibonacci(fibPosition);\n\n            do\n            {\n                fibonacciNumbers.Add(currentFibonaciNum);\n                currentFibonaciNum = Fibonacci(++fibPosition);\n            } while (currentFibonaciNum <= num);\n\n            uint temp = num;\n            StringBuilder output = new StringBuilder();\n\n            foreach (uint item in fibonacciNumbers.Reverse())\n            {\n                if (item <= temp)\n                {\n                    output.Append(\"1\");\n                    temp -= item;\n                }\n                else\n                {\n                    output.Append(\"0\");\n                }\n            }\n\n            return output.ToString();\n        }\n\n        static void Main(string[] args)\n        {\n            for (uint i = 1; i <= 20; i++)\n            {\n                string zeckendorfRepresentation = Zeckendorf(i);\n                Console.WriteLine(string.Format(\"{0} : {1}\", i, zeckendorfRepresentation));\n            }\n\n            Console.ReadKey();\n        }\n    }\n}\n"}
{"title": "Zero to the zero power", "language": "C sharp|C#", "task": "Some computer programming languages are not exactly consistent   (with other computer programming languages)   \nwhen   ''raising zero to the zeroth power'':     00\n\n\n;Task:\nShow the results of raising   zero   to the   zeroth   power.\n\n\nIf your computer language objects to      '''0**0'''      or      '''0^0'''      at compile time,   you may also try something like:\n            x = 0\n            y = 0\n            z = x**y\n            say  'z='  z\n\n\n'''Show the result here.'''\nAnd of course use any symbols or notation that is supported in your computer programming language for exponentiation. \n\n\n;See also:\n* The Wiki entry: Zero to the power of zero. \n* The Wiki entry: Zero to the power of zero: History.\n* The MathWorld(tm) entry: exponent laws.\n** Also, in the above MathWorld(tm) entry, see formula ('''9'''): x^0=1.\n* The OEIS entry: The special case of zero to the zeroth power\n\n", "solution": "using System;\n\nnamespace ZeroToTheZeroeth\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            double k = Math.Pow(0, 0);\n            Console.Write(\"0^0 is {0}\", k);           \n        }\n    }\n}"}