Finding permutations in strings

In C++ the Standard Template Library provides us with std::next_permutation to easily implement this.

#include <iostream>
#include <algorithm>
#include <iterator>
#include <string.h>
  
int main()
{
    char str[] = "abcd";
    const size_t len = strlen( str );
  
    do
    {
        std::copy( str,
        str + len,
        std::ostream_iterator<char>( std::cout ) );
        std::cout << std::endl;
    }
    while ( std::next_permutation( str, str + len ) );

	return 0;
}

Giving the following output:

The C# / .NET framework does not have an equivalent for std::next_permutation, but is straightforward enough to implement:

This following StackOverflow post gives an excellent C# implementation of next_permutation, which I’ve used here:

https://stackoverflow.com/questions/2390954/how-would-you-calculate-all-possible-permutations-of-0-through-n-iteratively/12768718#12768718

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

namespace permutations_cs
{
    class Program
    {
        static bool next_permutation<T>(IList<T> a) where T : IComparable
        {
            if (a.Count < 2) return false;
            var k = a.Count - 2;

            while (k >= 0 && a[k].CompareTo(a[k + 1]) >= 0) k--;
            if (k < 0) return false;

            var l = a.Count - 1;
            while (l > k && a[l].CompareTo(a[k]) <= 0) l--;

            var tmp = a[k];
            a[k] = a[l];
            a[l] = tmp;

            var i = k + 1;
            var j = a.Count - 1;
            while (i < j)
            {
                tmp = a[i];
                a[i] = a[j];
                a[j] = tmp;
                i++;
                j--;
            }

            return true;
        }

        static void Main(string[] args)
        {
            char[] str = { 'a', 'b', 'c', 'd' };     

            do
            {
                Console.WriteLine(str);
            }
            while ( next_permutation( str ) );
        }
    }
}

Giving an identical output: