Lets start with jump search algorithm and add more search problems to this repository.

The current implementation sets the value of the Vertices array to null at the index of the vertex to be removed, and decrements the Count member. This adds a null entry to the array and keeps the index of all other vertices the same. Since Count is decremented, the last element in the array will be overwritten when adding a new vertex.

I made a simple update to the test case to show that the index of the last vertex before the Remove operation will have the same index as a newly added vertex after the Remove operation (Assert.AreNotEqual). The test case fails. This will clearly have consequences since the index is used for all other operations.

[Test]
        public void GraphRemoveVertexTest_Success()
        {
            var graph = new DirectedWeightedGraph<char>(10);
            var vertexA = graph.AddVertex('A');
            var vertexB = graph.AddVertex('B');
            var vertexC = graph.AddVertex('C');
            graph.AddEdge(vertexB, vertexA, 5);
            graph.AddEdge(vertexC, vertexA, 5);
            var neighborsB = graph.GetNeighbors(vertexB).ToList();
            var neighborsC = graph.GetNeighbors(vertexC).ToList();

            graph.RemoveVertex(vertexA);

            var vertexD = graph.AddVertex('D');
            Assert.AreNotEqual(vertexC.Index, vertexD.Index);
            
            neighborsB.Should().HaveCount(1);
            neighborsB[0].Should().Be(vertexA);
            neighborsC.Should().HaveCount(1);
            neighborsC[0].Should().Be(vertexA);
            graph.GetNeighbors(vertexB).Should().HaveCount(0);
            graph.GetNeighbors(vertexC).Should().HaveCount(0);

        }

The links in the menu are broken as file structure of the repo has changed recently, needs fix.

The implementation of InsertionSorter is wrong. It's a copy of selection sort

Wikipedia example (InsersionSort)

i ← 1
while i < length(A)
j ← i
while j > 0 and A[j-1] > A[j]
swap A[j] and A[j-1]
j ← j - 1
end while
i ← i + 1
end while

currently InsertionSorter is equal to SelectionSorter

The Algorithms.Numeric.Factorial.Calculate function takes an int as input and returns a long; the function will overflow with an input greater than 20. Calculate should take a BigInteger as input and return one as output.

Additionally, the function checks input for less than zero. I would recommend putting input error checking outside of the Calculate function, in the ap[plications code (not the library), so that iterative functions that call it don't take the performance hit. In this case I would merely state it in the comment.

I have made the change in my test environment and it appears the change only breaks the Maclaurin.cs file; the fix for this appears to be to perform explicit type conversion on the return result.

I can submit the corrections if desired.

Please add more algorithms to this repo.

See the structure and README of this repo for reference
https://github.com/TheAlgorithms/Python

I have gone through repo and noticed there is StackBasedQueue but not QueueBasedStack.It is possible to implement stack using queue but Pop operation time complexity is O(n).But for completeness if it is okay I can add QueueBasedStack with a pull request.

public class QueueBasedStack<T>
    {
        private readonly Queue<T> queue;

        public QueueBasedStack() => queue = new Queue<T>();

        /// <summary>
        ///     Clears the stack
        /// </summary>
        public void Clear() => queue.Clear();

        public bool IsEmpty() => queue.Count == 0;

        /// <summary>
        ///     Adds an item on top of the stack
        /// </summary>
        /// <param name="item">Item to be added on top of stack</param>
        public void Push(T item) => queue.Enqueue(item);

        /// <summary>
        ///     Removes an item from  top of the stack and returns it 
        /// </summary>
        /// <returns>item on top of stack</returns>
        /// <exception cref="InvalidOperationException">Throw if stack is empty</exception>
        public T Pop()
        {
            if(IsEmpty())
            {
                throw new InvalidOperationException("The stack contains no items.");
            }
            for (int i = 0; i < queue.Count - 1; i++)
            {
                queue.Enqueue(queue.Dequeue());
            }
            return queue.Dequeue();
        }

        /// <summary>
        ///     return an item from the top of the stack without removing it
        /// </summary>
        /// <returns>item on top of the stack</returns>
        /// <exception cref="InvalidOperationException">Throw if stack is empty</exception>
        public T Peek()
        {
            if(IsEmpty())
            {
                throw new InvalidOperationException("The stack contains no items.");
            }
            for (int i = 0; i < queue.Count - 1; i++)
            {
                queue.Enqueue(queue.Dequeue());
            }
            var item = queue.Peek();
            queue.Enqueue(queue.Dequeue());
            return item;

        }

        /// <summary>
        ///     returns the count of items on the stack
        /// </summary>
        /// <returns>number of items on the stack</returns>
        public int Length() => queue.Count;

    }

Feel free to propose and/or implement new data structures, I will add them to the list below :)
List of data structures that would be great to see in this repo:
Basic:

• Sorted List

Heaps:

• Fibonacci heap
• Pairing heap

Trees:

• Scapegoat tree
• Finger tree
• Van Emde-Boas tree
• Suffix trie
• B-tree
• B+ tree
• Interval tree
• Red-Black tree
• AVL-tree
• Splay-tree
• Merkle tree
• R-tree
• KD-tree
• Hash array mapped trie
• Ball tree

Probabilistic:

• Quotient filter

Other:

• Rope
• Skip list
• Zipper
• Disjoint set
• Work Stealing Queue
• Inverted index
• Gap buffer
• Nested sets
• Half-Edge data structure
• Unrolled linked list

As a part of migration to .NET 8 in #425, we need to update to the latest major versions of the libraries we use:

• coverlet.collector to 6.*
• FluentAssertions to 6.*
• Microsoft.NET.Test.Sdk to 17.*
• NUnit to 4.*

Feel free to grab and update one of them!

I propose to add [algorithm/data structure] [name]. It helps to solve problems such as [...]. It's best described in book(s), on website(s): [...].

FactorialSequence.cs uses var n = 0; as an initializer, which turns n into an int; it should be a BigInteger.

BigInteger includes a constant of 1, so there is no need to create a new one.

The code can also be simplified and optimized.

I propose to update all algorithms to match coding standards. As a reference, please take a look at already refreshed algorithms. I will update this checklist as necessary. Feel free to make PRs and reference this issue there.

Encoders

• Caesar
• Hill
• Vigenere

Data Compression

• Huffman Encoding
• Shannon-Fano Encoding

Numeric

• Binary GCD
• Euclidean GCD
• Other
• Fermat Prime Checker
• Prime Finder
• Sieve of Eratosthenes
• Vowel Checker
• Searches
• A-Star
• Binary
• Linear

Sorts

• Binary Insertion
• Bogo
• Bubble
• Bucket
• Cocktail
• Cycle
• Heap
• Insertion
• Merge
• Pancake
• Quick
• Radix
• Selection
• Shell

String

• Longest Consecutive Character
• Palindrome Checker

Traversals

• Tree Traversal

Describe the bug
The Dijkstra algorithm is not well implemented because when it selects the the next node to visit, it does by choosing the cheapest adjacent node (to the current node) instead of the non visited node with the cheapest path from the starting node. This means that it will not visit some nodes (because it acts kind of like a greedy algorithm) and it will produce incorrect shortest paths.

To Reproduce

Taking DijkstraTest1_Success and modifying by adding 2 nodes:

var w = graph.AddVertex('W');
var z = graph.AddVertex('Z');

And adding 2 edges:

graph.AddEdge(a, w, 50);
graph.AddEdge(w, a, 50);

graph.AddEdge(w, z, 1);
graph.AddEdge(z, w, 1);

We get that the path from a to z is not found:

shortestPathList[5].Vertex.Should().Be(w);
shortestPathList[5].Distance.Should().Be(50);
shortestPathList[5].PreviousVertex.Should().Be(a);
shortestPathList[5].ToString().Should()
.Be($"Vertex: {w} - Distance: {50} - Previous: {a}");

shortestPathList[6].Vertex.Should().Be(z);
shortestPathList[6].Distance.Should().Be(51);
shortestPathList[6].PreviousVertex.Should().Be(w);
shortestPathList[6].ToString().Should()
.Be($"Vertex: {z} - Distance: {51} - Previous: {w}");

Expected shortestPathList[6].Distance to be 51.0, but found 1.7976931348623157E+308.

You can also make it find wrong paths if you cheat the greedy nature of the implementation.

Expected behavior

It should find a path from a to z.

Actual behavior
It doesnt.

Feel free to propose and/or implement new sequences, I will add them to the list below :)
List of some interesting OEIS sequences that would be great to see in this repo (but you can implement any one from OEIS, not only from this list):

• A000004 Zero
• A000005 Number of Divisors of n
• A000008 Number of ways of making change for n cents using coins of 1, 2, 5, 10 cents
• A000010 Euler totient function of n

Hard work...

It has more features than the BitArray structure, such as the add/remove one or more bits to an existing BitList, and is convertible to all native types and it has many more ctor.
I can send it to you to modify it as you want.

Describe the bug
Binary seach algorithm in C# does not run.

To Reproduce
Run provided C# code.

Error:

---- RESET ----
Could not execute because the specified command or file was not found.
Possible reasons for this include:
  * You misspelled a built-in dotnet command.
  * You intended to execute a .NET program, but dotnet-bin/Debug/net5.0/533c8da4-37af-497a-ad63-1458bee97c5d.dll does not exist.
  * You intended to run a global tool, but a dotnet-prefixed executable with this name could not be found on the PATH.
Exited with code 1

https://the-algorithms.com/algorithm/binary-search?lang=c-sharp

Recommend adding a BigInteger CountOfDivisors(BigInteger n) function to Algorithms.Numeric.

Also recommend modifying DivisorsCountSequence.cs to use that function. Current algorithm of DivisorsCountSequence.cs is O(n) for each n, when it should be O(sqrt(n)).

The GO uses dynamic hierarchical layout. Perhaps C-Sharp can gradually migrate that into this layout.
Why: the community can quickly has a top overview, which algorithms have been selected and the text associated with it for community refinement and further contribution

Algorithms

Add a .travis.yml file to this repository.
Refer to this doc https://docs.travis-ci.com/user/languages/csharp/

This repo contains a bunch of good algorithms and data structures. Unfortunately, in my opinion, they are not organized well (I mean naming conventions and folder structure). Naming and structure don't conform to the best practices that are used in C# projects. I would like to volunteer and get this work done in my free time if owners don't mind. I hope that will give this repo a fresh look.

We currently have four algorithms that implement block cipher padding. These implementations essentially share the same functions: AddPadding, RemovePadding and GetPaddingCount.

I am also planning to add three more padding algorithms that are essentially block cipher paddings.

Having a common interface would help maintain uniformity among all these algorithms.

Looking forward to your thoughts on this.

I just got started with contributing to this repo and it took me a while to figure out the basics of NUnit, codecov etc. I think it might be a good idea to give a short explanation in CONTRIBUTING.md to give new contributers in the future a head-start.

I thought something along the following lines: Please implement tests, put the test in a separate file in the algorithms-test folder, name the test-class correspondingly, we use NUnit for tests (link), a basic test can be implemented so&so, the test can be locally run so&so, we use codecov which checks that each conditional branch gets tested, please try to implement tests for the different branches of each public method.

It might also be good to add something about coding style, for example suggest a code formatter that can be locally used, but I myself don't know about that part.

If this sounds like a good idea then I would get started on a draft.

Describe the bug
When setting the initial values of tiles next to the starting point they're not assigned an open state which often leads to them being overriden other nearby tiles.

This is the code that initiates the costs at the starting point

// Add connecting nodes if traversable
                if (node.Traversable)
                {
                    // Calculate the Costs
                    node.CurrentCost = from.CurrentCost + from.DistanceTo(node) * node.TraversalCostMultiplier;
                    node.EstimatedCost = from.CurrentCost + node.DistanceTo(to);
                    // Enqueue
                    open.Enqueue(node);
                }

And this is the code that iteratively sets the costs

  // Adds a previously not "seen" node into the Queue
                if (connected.State == NodeState.Unconsidered)
                {
                    connected.Parent = current;
                    connected.CurrentCost =
                        current.CurrentCost + current.DistanceTo(connected) * connected.TraversalCostMultiplier;
                    connected.EstimatedCost = connected.CurrentCost + connected.DistanceTo(to);
                    connected.State = NodeState.Open;
                    queue.Enqueue(connected);
                }
                else if (current != connected)
                {
                    // Updating the cost of the node if the current way is cheaper than the previous
                    var newCCost = current.CurrentCost + current.DistanceTo(connected);
                    var newTCost = newCCost + current.EstimatedCost;
                    if (newTCost < connected.TotalCost)
                    {
                        connected.Parent = current;
                        connected.CurrentCost = newCCost;
                    }
                }

The solution is a one line fix, altough it also might make more sense to move both of those code snipets into a sningle function

node.State = NodeState.Open;
i was considering doing a pull request however i do not have the time to write tests for this to fit in wth the guidelnes(since astar does not have any to begin with)

To Reproduce
There's no tests so it's rather difficult as i've only discovered it myself when using the code as part of a bigger project

Expected behavior
The iterative code that sets the costs does NOT override costs of tiles if the cost is higher - which it does as seen in the snipped above UNLESS the tile is unconsidered at which point it assumes the cost is 0 and overrides the cost without checking. The issue here is that all initial tiles start out as unconsidered rather than as open.

Actual behavior
In scenarios where one of the corner nodes is evaluated first

LGTM.com will be shut down in December 2022 — we recommend that you use GitHub code scanning instead. Read more in our blog post on the GitHub blog.

https://github.blog/2022-08-15-the-next-step-for-lgtm-com-github-code-scanning/

I propose to refactor Stack ArrayBasedStack. I was reading some C# algorithms and not understand the reason for use a iteration in line 48 of ArrayBasedStack.cs . I believe this syntax is more readable:

public ArrayBasedStack(T[] items)
{
    stack = items;
    top = items.Length - 1;
}

If this refactoring makes sense, I can make this change :)

I was very surprised to see that BitArray uses bool[] as an underlying type. If you didn't know, the bool type in C# actually allocates an entire byte of memory because that is the minimum addressable size used by the CLR. You waste 7 bits for every bool. See https://stackoverflow.com/questions/2308034/primitive-boolean-size-in-c-sharp/2308052

I see @LorenzoLotti was the original contributor so I'm tagging them.

A maximum performance gain would be to use byte[], int[], or long[] as the underlying data type and then use bitwise operations to get the bit value you actually want.

This improvement seems minor compared to the effort to implement, but could maximize memory usage for very large data sets.

.NET 5.0 is Out of support
https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core

If there are no problems, I will contribute.

I propose to add [algorithm] [set bit count in a number]. It helps to solve problems such as [calculating the no of set bits ]. It's best described on the website(s): [https://www.geeksforgeeks.org/count-set-bits-in-an-integer/].

BlowfishEncoder tests fail from time to time for no apparent reason. See test log below for more details:

Failed BlowfishEncoder_Decryption_ShouldWorkCorrectly [105 ms]
  Error Message:
   Expected result to be 
"123456abcd1325[36](https://github.com/TheAlgorithms/C-Sharp/actions/runs/7259358644/job/19776334635#step:6:37)", but 
"1c0dfbe8468a4240" differs near "c0d" (index 1).
  Stack Trace:
     at FluentAssertions.Execution.LateBoundTestFramework.Throw(String message)
   at FluentAssertions.Execution.TestFrameworkProvider.Throw(String message)
   at FluentAssertions.Execution.DefaultAssertionStrategy.HandleFailure(String message)
   at FluentAssertions.Execution.AssertionScope.FailWith(Func`1 failReasonFunc)
   at FluentAssertions.Primitives.StringEqualityValidator.ValidateAgainstMismatch()
   at FluentAssertions.Primitives.StringAssertions.Be(String expected, String because, Object[] becauseArgs)
   at Algorithms.Tests.Encoders.BlowfishEncoderTests.BlowfishEncoder_Decryption_ShouldWorkCorrectly() in /home/runner/work/C-Sharp/C-Sharp/Algorithms.Tests/Encoders/BlowfishEncoderTests.cs:line 42


Failed!  - Failed:     1, Passed:  81[39](https://github.com/TheAlgorithms/C-Sharp/actions/runs/7259358644/job/19776334635#step:6:40), Skipped:     0, Total:  81[40](https://github.com/TheAlgorithms/C-Sharp/actions/runs/7259358644/job/19776334635#step:6:41), Duration: 1 m 11 s - Algorithms.Tests.dll (net6.0)

Algorithms.Numeric.BinomialCoefficient.Calculate is significantly limited by the inputs being int and the return value being long.; all should be BigInteger.

It can easily be optimized by not doing the extra calculations of factorial divided by factorial.

Error handling should be outside of this function for performance reasons, particularly sequences. Error exception references n when the inputs are num and k.

My test environment doesn't show this change breaking anything.

I've noticed that there are some dynamic programming problems scattered throughout this repository. I believe it would greatly benefit the community if we could gather all these problems under a dedicated 'Dynamic Programming' folder for easier accessibility, especially given how frequently dynamic programming questions come up in interviews.

Here are a couple of reasons why this would be a valuable addition:

Interview Preparation: Dynamic programming is a key topic in technical interviews, and having these problems grouped together would be a valuable resource for users preparing for interviews.
Improved Visibility: Currently, dynamic programming problems are a bit hard to spot within the repository. Grouping all of them under one folder will make them much more visible.

I can start organizing them under Problems -> Dynamic Programming folder.

Initial suggestions for Dynamic Programming problems as follows:
NEW PROBLEMS

1. Find factorial of a given number (Also available in sequences)
2. Find nth number in a Fibonacci series (Also available in sequences)

REORGANIZING PROBLEMS TO ABOVE MENTIONED FOLDER

1. Problems -> Dynamic Coin Change
2. Strings -> Levenshtein Distance

Please let me know if you're open to this suggestion and if you have any specific preferences.

I propose to add Z-block substring search algorithm, it finds all occurrences of a pattern in a text in linear time

We need to adopt MIT License to be seen by the entire Github community as a true sharing spirit community.

I propose to migrate to .NET 8 to use the latest features of .NET ecosystem.
I think we can do it in a few PRs to make them smaller and easier to review. One would just update .NET version and CI scripts and following would update NuGet packages and codebase.
Feel free to comment if you want to do it.

• SDK and build scripts
• File-scoped namespaces
• Implicit usings
• Nullable (if it's not enabled)
• Update dependencies

I propose adding the A* algorithm, a widely used graph traversal and path search method in computer science. A* is valued for its completeness, optimality, and efficiency, but it has a practical limitation in its memory usage (O(b^d)). Despite this, it often outperforms other algorithms, except in cases where graph pre-processing or memory-bounded approaches are applicable. This algorithm was introduced by Peter Hart, Nils Nilsson, and Bertram Raphael at Stanford Research Institute in 1968. It's an extension of Dijkstra's algorithm, using heuristics to guide its search. Unlike Dijkstra's, A* focuses on finding the shortest path from a specific source to a defined goal, rather than generating the entire shortest-path tree. This distinction is a necessary trade-off for employing a specific-goal-directed heuristic. I would love to implement this algorithm and provide detailed documentation, since I just studied this algorithm in my Algorithms and Data Structures course at university.
It's best described in book(s), on website(s):

• https://www.tandfonline.com/doi/full/10.1080/13658810801949850
• https://ieeexplore.ieee.org/document/4082128
• https://link.springer.com/chapter/10.1007/978-3-642-02094-0_7.

We need to replace System.Drawing.Common with something else because it's Windows-only since version 6.

I propose to use SkiaSharp instead. It's one of the alternatives to System.Drawing.Common Microsoft recommends here. Compared to other alternatives, it looks more popular and better maintained.

I'm not familiar with the interface SkiaSharp provides, but I assume it's different from what System.Drawing.Common has. Nevertheless, we use only the most basic drawing features in the repository, so it should be not too difficult to migrate.

This update is a part of #425.

Feel free to propose and/or implement new algorithms, I will add them to the list below :)
List of algorithms that would be great to see in this repo:

• Jump search
• Z-block substring search
• Homogeneous linear equations elimination algorithm
• MinHash
• FAME algorithm
• Chlamtac-Jain P-squared algorithm
• Welford's algorithm
• Kahn Topological Sort (Graph Algorithms)
• Coin Change Dynamic (Problems)
• Priority Queue, Based on Heapsort with maintained Heap property via Floyd's Algorithm (Data Structures)

This is a great project and I would like to help.

I think you should have a prime class and a variety of ways to calculate primes. What is in the SieveOfEratosthenes.cs file is calculating primes by dividing the number by all primes using memoization of previously calculated primes.

https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

From my perspective, NUnit has a lack of features to write unit tests with complex data on input. xUnit has attributes like MemberData, ClassData e.t.c. to make this task easier. Also, this framework provides a wider range of assertions and a more flexible way to create data generators for testing.