Список всех перестановок строки / целого числа

Немного измененная версия на C #, которая дает необходимые перестановки в массиве ЛЮБОГО типа.

    // USAGE: create an array of any type, and call Permutations()
    var vals = new[] {"a", "bb", "ccc"};
    foreach (var v in Permutations(vals))
        Console.WriteLine(string.Join(",", v)); // Print values separated by comma


public static IEnumerable<T[]> Permutations<T>(T[] values, int fromInd = 0)
{
    if (fromInd + 1 == values.Length)
        yield return values;
    else
    {
        foreach (var v in Permutations(values, fromInd + 1))
            yield return v;

        for (var i = fromInd + 1; i < values.Length; i++)
        {
            SwapValues(values, fromInd, i);
            foreach (var v in Permutations(values, fromInd + 1))
                yield return v;
            SwapValues(values, fromInd, i);
        }
    }
}

private static void SwapValues<T>(T[] values, int pos1, int pos2)
{
    if (pos1 != pos2)
    {
        T tmp = values[pos1];
        values[pos1] = values[pos2];
        values[pos2] = tmp;
    }
}

Прежде всего, наборы имеют перестановки, а не строки или целые числа, поэтому я просто предполагаю, что вы имеете в виду «набор символов в строке».

Обратите внимание, что в наборе размера n есть n! n-перестановки.

Следующий псевдокод (из Википедии), вызываемый с k = 1 ... n! даст все перестановки:

function permutation(k, s) {
    for j = 2 to length(s) {
        swap s[(k mod j) + 1] with s[j]; // note that our array is indexed starting at 1
        k := k / j; // integer division cuts off the remainder
    }
    return s;
}

Вот эквивалентный код Python (для индексов массива с отсчетом от 0):

def permutation(k, s):
    r = s[:]
    for j in range(2, len(s)+1):
        r[j-1], r[k%j] = r[k%j], r[j-1]
        k = k/j+1
    return r

Мне понравился подход FBryant87, поскольку он прост. К сожалению, он, как и многие другие "решения", не предлагает всех вариантов или, например, целое число, если оно содержит одну и ту же цифру более одного раза. Возьмем, к примеру, 656123. Линия:

var tail = chars.Except(new List<char>(){c});

использование Except приведет к удалению всех вхождений, т.е. когда c = 6, две цифры удаляются, и у нас остается, например, 5123. Поскольку ни одно из опробованных мной решений не помогло решить эту проблему, я решил попробовать решить ее сам, используя код FBryant87 в качестве основы. Вот что я придумал:

private static List<string> FindPermutations(string set)
    {
        var output = new List<string>();
        if (set.Length == 1)
        {
            output.Add(set);
        }
        else
        {
            foreach (var c in set)
            {
                // Remove one occurrence of the char (not all)
                var tail = set.Remove(set.IndexOf(c), 1);
                foreach (var tailPerms in FindPermutations(tail))
                {
                    output.Add(c + tailPerms);
                }
            }
        }
        return output;
    }

Я просто удаляю первое найденное вхождение, используя .Remove и .IndexOf. По крайней мере, похоже, работает так, как предназначено для моего использования. Я уверен, что его можно было сделать умнее.

Однако следует отметить одну вещь: результирующий список может содержать дубликаты, поэтому убедитесь, что вы либо вернули метод, например. вместо этого HashSet или удалите дубликаты после возврата, используя любой метод, который вам нравится.

Вот чисто функциональная реализация F #:

let factorial i =
    let rec fact n x =
        match n with
        | 0 -> 1
        | 1 -> x
        | _ -> fact (n-1) (x*n)
    fact i 1

let swap (arr:'a array) i j = [| for k in 0..(arr.Length-1) -> if k = i then arr.[j] elif k = j then arr.[i] else arr.[k] |]

let rec permutation (k:int,j:int) (r:'a array) =
    if j = (r.Length + 1) then r
    else permutation (k/j+1, j+1) (swap r (j-1) (k%j))

let permutations (source:'a array) = seq { for k = 0 to (source |> Array.length |> factorial) - 1 do yield permutation (k,2) source }

Производительность можно значительно улучшить, изменив свопинг, чтобы воспользоваться преимуществами изменчивой природы массивов CLR, но эта реализация является потокобезопасной по отношению к исходному массиву, и это может быть желательно в некоторых контекстах. Кроме того, для массивов с более чем 16 элементами int необходимо заменить типами с большей / произвольной точностью, поскольку факториал 17 приводит к переполнению int32.

Вот простое решение на С # с использованием рекурсии,

void Main()
{
    string word = "abc";
    WordPermuatation("",word);
}

void WordPermuatation(string prefix, string word)
{
    int n = word.Length;
    if (n == 0) { Console.WriteLine(prefix); }
    else
    {
        for (int i = 0; i < n; i++)
        {
            WordPermuatation(prefix + word[i],word.Substring(0, i) + word.Substring(i + 1, n - (i+1)));
        }
    }
}

Вот простая для понимания функция перестановки как для строковых, так и для целых чисел в качестве входных данных. С помощью этого вы даже можете установить длину вывода (которая в нормальном случае равна длине ввода)

Строка

    static ICollection<string> result;

    public static ICollection<string> GetAllPermutations(string str, int outputLength)
    {
        result = new List<string>();
        MakePermutations(str.ToCharArray(), string.Empty, outputLength);
        return result;
    }

    private static void MakePermutations(
       char[] possibleArray,//all chars extracted from input
       string permutation,
       int outputLength//the length of output)
    {
         if (permutation.Length < outputLength)
         {
             for (int i = 0; i < possibleArray.Length; i++)
             {
                 var tempList = possibleArray.ToList<char>();
                 tempList.RemoveAt(i);
                 MakePermutations(tempList.ToArray(), 
                      string.Concat(permutation, possibleArray[i]), outputLength);
             }
         }
         else if (!result.Contains(permutation))
            result.Add(permutation);
    }

а для Integer просто измените метод вызывающего, и MakePermutations () останется нетронутым:

    public static ICollection<int> GetAllPermutations(int input, int outputLength)
    {
        result = new List<string>();
        MakePermutations(input.ToString().ToCharArray(), string.Empty, outputLength);
        return result.Select(m => int.Parse(m)).ToList<int>();
    }

пример 1: GetAllPermutations ("abc", 3); "abc" "acb" "bac" "bca" "cab" "cba"

пример 2: GetAllPermutations ("abcd", 2); "ab" "ac" "ad" "ba" "bc" "bd" "ca" "cb" "cd" "da" "db" "dc"

пример 3: GetAllPermutations (486,2); 48 46 84 86 64 68

Основываясь на решении @ Peter, вот версия, которая объявляет простой метод расширения Permutations() в стиле LINQ, который работает с любым IEnumerable<T>.

Использование (на примере строковых символов):

foreach (var permutation in "abc".Permutations())
{
    Console.WriteLine(string.Join(", ", permutation));
}

Выходы:

a, b, c
a, c, b
b, a, c
b, c, a
c, b, a
c, a, b

Или на любом другом типе коллекции:

foreach (var permutation in (new[] { "Apples", "Oranges", "Pears"}).Permutations())
{
    Console.WriteLine(string.Join(", ", permutation));
}

Выходы:

Apples, Oranges, Pears
Apples, Pears, Oranges
Oranges, Apples, Pears
Oranges, Pears, Apples
Pears, Oranges, Apples
Pears, Apples, Oranges

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

public static class PermutationExtension
{
    public static IEnumerable<T[]> Permutations<T>(this IEnumerable<T> source)
    {
        var sourceArray = source.ToArray();
        var results = new List<T[]>();
        Permute(sourceArray, 0, sourceArray.Length - 1, results);
        return results;
    }

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

    private static void Permute<T>(T[] elements, int recursionDepth, int maxDepth, ICollection<T[]> results)
    {
        if (recursionDepth == maxDepth)
        {
            results.Add(elements.ToArray());
            return;
        }

        for (var i = recursionDepth; i <= maxDepth; i++)
        {
            Swap(ref elements[recursionDepth], ref elements[i]);
            Permute(elements, recursionDepth + 1, maxDepth, results);
            Swap(ref elements[recursionDepth], ref elements[i]);
        }
    }
}

Вот функция, которая распечатает все перестановки. Эта функция реализует логику. Объяснил Петр.

public class Permutation
{
    //http://www.java2s.com/Tutorial/Java/0100__Class-Definition/RecursivemethodtofindallpermutationsofaString.htm

    public static void permuteString(String beginningString, String endingString)
    {           

        if (endingString.Length <= 1)
            Console.WriteLine(beginningString + endingString);
        else
            for (int i = 0; i < endingString.Length; i++)
            {

                String newString = endingString.Substring(0, i) + endingString.Substring(i + 1);

                permuteString(beginningString + endingString.ElementAt(i), newString);

            }
    }
}

    static void Main(string[] args)
    {

        Permutation.permuteString(String.Empty, "abc");
        Console.ReadLine();

    }

Ниже представлена ​​моя реализация перестановки. Не обращайте внимания на имена переменных, так как я делал это для развлечения :)

class combinations
{
    static void Main()
    {

        string choice = "y";
        do
        {
            try
            {
                Console.WriteLine("Enter word :");
                string abc = Console.ReadLine().ToString();
                Console.WriteLine("Combinatins for word :");
                List<string> final = comb(abc);
                int count = 1;
                foreach (string s in final)
                {
                    Console.WriteLine("{0} --> {1}", count++, s);
                }
                Console.WriteLine("Do you wish to continue(y/n)?");
                choice = Console.ReadLine().ToString();
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc);
            }
        } while (choice == "y" || choice == "Y");
    }

    static string swap(string test)
    {
        return swap(0, 1, test);
    }

    static List<string> comb(string test)
    {
        List<string> sec = new List<string>();
        List<string> first = new List<string>();
        if (test.Length == 1) first.Add(test);
        else if (test.Length == 2) { first.Add(test); first.Add(swap(test)); }
        else if (test.Length > 2)
        {
            sec = generateWords(test);
            foreach (string s in sec)
            {
                string init = s.Substring(0, 1);
                string restOfbody = s.Substring(1, s.Length - 1);

                List<string> third = comb(restOfbody);
                foreach (string s1 in third)
                {
                    if (!first.Contains(init + s1)) first.Add(init + s1);
                }


            }
        }

        return first;
    }

    static string ShiftBack(string abc)
    {
        char[] arr = abc.ToCharArray();
        char temp = arr[0];
        string wrd = string.Empty;
        for (int i = 1; i < arr.Length; i++)
        {
            wrd += arr[i];
        }

        wrd += temp;
        return wrd;
    }

    static List<string> generateWords(string test)
    {
        List<string> final = new List<string>();
        if (test.Length == 1)
            final.Add(test);
        else
        {
            final.Add(test);
            string holdString = test;
            while (final.Count < test.Length)
            {
                holdString = ShiftBack(holdString);
                final.Add(holdString);
            }
        }

        return final;
    }

    static string swap(int currentPosition, int targetPosition, string temp)
    {
        char[] arr = temp.ToCharArray();
        char t = arr[currentPosition];
        arr[currentPosition] = arr[targetPosition];
        arr[targetPosition] = t;
        string word = string.Empty;
        for (int i = 0; i < arr.Length; i++)
        {
            word += arr[i];

        }

        return word;

    }
}

Вот пример высокого уровня, который я написал, который иллюстрирует объяснение, данное Питером на человеческом языке:

    public List<string> FindPermutations(string input)
    {
        if (input.Length == 1)
            return new List<string> { input };
        var perms = new List<string>();
        foreach (var c in input)
        {
            var others = input.Remove(input.IndexOf(c), 1);
            perms.AddRange(FindPermutations(others).Select(perm => c + perm));
        }
        return perms;
    }

Это мое решение, которое мне легко понять

class ClassicPermutationProblem
{
    ClassicPermutationProblem() { }

    private static void PopulatePosition<T>(List<List<T>> finalList, List<T> list, List<T> temp, int position)
    {
         foreach (T element in list)
         {
             List<T> currentTemp = temp.ToList();
             if (!currentTemp.Contains(element))
                currentTemp.Add(element);
             else
                continue;

             if (position == list.Count)
                finalList.Add(currentTemp);
             else
                PopulatePosition(finalList, list, currentTemp, position + 1);
        }
    }

    public static List<List<int>> GetPermutations(List<int> list)
    {
        List<List<int>> results = new List<List<int>>();
        PopulatePosition(results, list, new List<int>(), 1);
        return results;
     }
}

static void Main(string[] args)
{
    List<List<int>> results = ClassicPermutationProblem.GetPermutations(new List<int>() { 1, 2, 3 });
}

Если производительность и память являются проблемой, я предлагаю эту очень эффективную реализацию. Согласно алгоритму кучи в Википедии, он должен быть самым быстрым. Надеюсь, он вам подойдет :-)!

Так же, как это сравнение с реализацией Linq для 10! (код включен):

• Это: 36288000 элементов в 235 миллисекундах

• Linq: 36288000 элементов в 50051 миллисекундах

  using System;
  using System.Collections.Generic;
  using System.Diagnostics;
  using System.Linq;
  using System.Runtime.CompilerServices;
  using System.Text;
  
  namespace WpfPermutations
  {
      /// <summary>
      /// EO: 2016-04-14
      /// Generator of all permutations of an array of anything.
      /// Base on Heap's Algorithm. See: https://en.wikipedia.org/wiki/Heap%27s_algorithm#cite_note-3
      /// </summary>
      public static class Permutations
      {
          /// <summary>
          /// Heap's algorithm to find all pmermutations. Non recursive, more efficient.
          /// </summary>
          /// <param name="items">Items to permute in each possible ways</param>
          /// <param name="funcExecuteAndTellIfShouldStop"></param>
          /// <returns>Return true if cancelled</returns> 
          public static bool ForAllPermutation<T>(T[] items, Func<T[], bool> funcExecuteAndTellIfShouldStop)
          {
              int countOfItem = items.Length;
  
              if (countOfItem <= 1)
              {
                  return funcExecuteAndTellIfShouldStop(items);
              }
  
              var indexes = new int[countOfItem];
              for (int i = 0; i < countOfItem; i++)
              {
                  indexes[i] = 0;
              }
  
              if (funcExecuteAndTellIfShouldStop(items))
              {
                  return true;
              }
  
              for (int i = 1; i < countOfItem;)
              {
                  if (indexes[i] < i)
                  { // On the web there is an implementation with a multiplication which should be less efficient.
                      if ((i & 1) == 1) // if (i % 2 == 1)  ... more efficient ??? At least the same.
                      {
                          Swap(ref items[i], ref items[indexes[i]]);
                      }
                      else
                      {
                          Swap(ref items[i], ref items[0]);
                      }
  
                      if (funcExecuteAndTellIfShouldStop(items))
                      {
                          return true;
                      }
  
                      indexes[i]++;
                      i = 1;
                  }
                  else
                  {
                      indexes[i++] = 0;
                  }
              }
  
              return false;
          }
  
          /// <summary>
          /// This function is to show a linq way but is far less efficient
          /// </summary>
          /// <typeparam name="T"></typeparam>
          /// <param name="list"></param>
          /// <param name="length"></param>
          /// <returns></returns>
          static IEnumerable<IEnumerable<T>> GetPermutations<T>(IEnumerable<T> list, int length)
          {
              if (length == 1) return list.Select(t => new T[] { t });
  
              return GetPermutations(list, length - 1)
                  .SelectMany(t => list.Where(e => !t.Contains(e)),
                      (t1, t2) => t1.Concat(new T[] { t2 }));
          }
  
          /// <summary>
          /// Swap 2 elements of same type
          /// </summary>
          /// <typeparam name="T"></typeparam>
          /// <param name="a"></param>
          /// <param name="b"></param>
          [MethodImpl(MethodImplOptions.AggressiveInlining)]
          static void Swap<T>(ref T a, ref T b)
          {
              T temp = a;
              a = b;
              b = temp;
          }
  
          /// <summary>
          /// Func to show how to call. It does a little test for an array of 4 items.
          /// </summary>
          public static void Test()
          {
              ForAllPermutation("123".ToCharArray(), (vals) =>
              {
                  Debug.Print(String.Join("", vals));
                  return false;
              });
  
              int[] values = new int[] { 0, 1, 2, 4 };
  
              Debug.Print("Non Linq");
              ForAllPermutation(values, (vals) =>
              {
                  Debug.Print(String.Join("", vals));
                  return false;
              });
  
              Debug.Print("Linq");
              foreach(var v in GetPermutations(values, values.Length))
              {
                  Debug.Print(String.Join("", v));
              }
  
              // Performance
              int count = 0;
  
              values = new int[10];
              for(int n = 0; n < values.Length; n++)
              {
                  values[n] = n;
              }
  
              Stopwatch stopWatch = new Stopwatch();
              stopWatch.Reset();
              stopWatch.Start();
  
              ForAllPermutation(values, (vals) =>
              {
                  foreach(var v in vals)
                  {
                      count++;
                  }
                  return false;
              });
  
              stopWatch.Stop();
              Debug.Print($"Non Linq {count} items in {stopWatch.ElapsedMilliseconds} millisecs");
  
              count = 0;
              stopWatch.Reset();
              stopWatch.Start();
  
              foreach (var vals in GetPermutations(values, values.Length))
              {
                  foreach (var v in vals)
                  {
                      count++;
                  }
              }
  
              stopWatch.Stop();
              Debug.Print($"Linq {count} items in {stopWatch.ElapsedMilliseconds} millisecs");
  
          }
      }
  }
  

Вот мое решение на JavaScript (NodeJS). Основная идея состоит в том, что мы берем по одному элементу за раз, «удаляем его» из строки, меняем остальные символы и вставляем элемент впереди.

function perms (string) {
  if (string.length == 0) {
    return [];
  }
  if (string.length == 1) {
    return [string];
  }
  var list = [];
  for(var i = 0; i < string.length; i++) {
    var invariant = string[i];
    var rest = string.substr(0, i) + string.substr(i + 1);
    var newPerms = perms(rest);
    for (var j = 0; j < newPerms.length; j++) {
      list.push(invariant + newPerms[j]);
    }
  }
  return list;
}

module.exports = perms;

А вот и тесты:

require('should');
var permutations = require('../src/perms');

describe('permutations', function () {
  it('should permute ""', function () {
    permutations('').should.eql([]);
  })

  it('should permute "1"', function () {
    permutations('1').should.eql(['1']);
  })

  it('should permute "12"', function () {
    permutations('12').should.eql(['12', '21']);
  })

  it('should permute "123"', function () {
    var expected = ['123', '132', '321', '213', '231', '312'];
    var actual = permutations('123');
    expected.forEach(function (e) {
      actual.should.containEql(e);
    })
  })

  it('should permute "1234"', function () {
    // Wolfram Alpha FTW!
    var expected = ['1234', '1243', '1324', '1342', '1423', '1432', '2134', '2143', '2314', '2341', '2413', '2431', '3124', '3142', '3214', '3241', '3412', '3421', '4123', '4132'];
    var actual = permutations('1234');
    expected.forEach(function (e) {
      actual.should.containEql(e);
    })
  })
})

Вот самое простое решение, о котором я могу думать:

let rec distribute e = function
  | [] -> [[e]]
  | x::xs' as xs -> (e::xs)::[for xs in distribute e xs' -> x::xs]

let permute xs = Seq.fold (fun ps x -> List.collect (distribute x) ps) [[]] xs

Функция distribute принимает новый элемент e и список n элементов и возвращает список из n+1 списков, каждый из которых e вставлен в другое место. Например, вставив 10 в каждое из четырех возможных мест в списке [1;2;3]:

> distribute 10 [1..3];;
val it : int list list =
  [[10; 1; 2; 3]; [1; 10; 2; 3]; [1; 2; 10; 3]; [1; 2; 3; 10]]

Функция permute складывается по каждому элементу, по очереди распределяя по уже накопленным перестановкам, достигая высшей точки во всех перестановках. Например, 6 перестановок списка [1;2;3]:

> permute [1;2;3];;
val it : int list list =
  [[3; 2; 1]; [2; 3; 1]; [2; 1; 3]; [3; 1; 2]; [1; 3; 2]; [1; 2; 3]]

Изменение fold на scan, чтобы сохранить промежуточные аккумуляторы, проливает некоторый свет на то, как перестановки генерируются для элемента за раз:

> Seq.scan (fun ps x -> List.collect (distribute x) ps) [[]] [1..3];;
val it : seq<int list list> =
  seq
    [[[]]; [[1]]; [[2; 1]; [1; 2]];
     [[3; 2; 1]; [2; 3; 1]; [2; 1; 3]; [3; 1; 2]; [1; 3; 2]; [1; 2; 3]]]

Перечисляет перестановки строки. Избегает дублирования при повторении символов:

using System;
using System.Collections;

class Permutation{
  static IEnumerable Permutations(string word){
    if (word == null || word.Length <= 1) {
      yield return word;
      yield break;
    }

    char firstChar = word[0];
    foreach( string subPermute in Permutations (word.Substring (1)) ) {
      int indexOfFirstChar = subPermute.IndexOf (firstChar);
      if (indexOfFirstChar == -1) indexOfFirstChar = subPermute.Length;

      for( int index = 0; index <= indexOfFirstChar; index++ )
        yield return subPermute.Insert (index, new string (firstChar, 1));
    }
  }

  static void Main(){
    foreach( var permutation in Permutations ("aab") )
      Console.WriteLine (permutation);
  }
}

Вот функция, которая рекурсивно распечатает все перестановки.

public void Permutations(string input, StringBuilder sb)
    {
        if (sb.Length == input.Length)
        {
            Console.WriteLine(sb.ToString());
            return;
        }

        char[] inChar = input.ToCharArray();

        for (int i = 0; i < input.Length; i++)
        {
            if (!sb.ToString().Contains(inChar[i]))
            {
                sb.Append(inChar[i]);
                Permutations(input, sb);    
                RemoveChar(sb, inChar[i]);
            }
        }
    }

private bool RemoveChar(StringBuilder input, char toRemove)
    {
        int index = input.ToString().IndexOf(toRemove);
        if (index >= 0)
        {
            input.Remove(index, 1);
            return true;
        }
        return false;
    }

Вот ответ C #, который немного упрощен.

public static void StringPermutationsDemo()
{
    strBldr = new StringBuilder();

    string result = Permute("ABCD".ToCharArray(), 0);
    MessageBox.Show(result);
}     

static string Permute(char[] elementsList, int startIndex)
{
    if (startIndex == elementsList.Length)
    {
        foreach (char element in elementsList)
        {
            strBldr.Append(" " + element);
        }
        strBldr.AppendLine("");
    }
    else
    {
        for (int tempIndex = startIndex; tempIndex <= elementsList.Length - 1; tempIndex++)
        {
            Swap(ref elementsList[startIndex], ref elementsList[tempIndex]);

            Permute(elementsList, (startIndex + 1));

            Swap(ref elementsList[startIndex], ref elementsList[tempIndex]);
        }
    }

    return strBldr.ToString();
}

static void Swap(ref char Char1, ref char Char2)
{
    char tempElement = Char1;
    Char1 = Char2;
    Char2 = tempElement;
}

Вывод:

1 2 3
1 3 2

2 1 3
2 3 1

3 2 1
3 1 2

Вот еще одна реализация упомянутого алгоритма.

public class Program
{
    public static void Main(string[] args)
    {
        string str = "abcefgh";
        var astr = new Permutation().GenerateFor(str);
        Console.WriteLine(astr.Length);
        foreach(var a in astr)
        {
            Console.WriteLine(a);
        }
        //a.ForEach(Console.WriteLine);
    }
}

class Permutation
{
    public string[] GenerateFor(string s)
    {  

        if(s.Length == 1)
        {

            return new []{s}; 
        }

        else if(s.Length == 2)
        {

            return new []{s[1].ToString()+s[0].ToString(),s[0].ToString()+s[1].ToString()};

        }

        var comb = new List<string>();

        foreach(var c in s)
        {

            string cStr = c.ToString();

            var sToProcess = s.Replace(cStr,"");
            if (!string.IsNullOrEmpty(sToProcess) && sToProcess.Length>0)
            {
                var conCatStr = GenerateFor(sToProcess);



                foreach(var a in conCatStr)
                {
                    comb.Add(c.ToString()+a);
                }


            }
        }
        return comb.ToArray();

    }
}

База / пересмотр на Pengyang ответ < / а>

И вдохновлен перестановками в javascript

Версия C # FunctionalPermutations должна быть такой

static IEnumerable<IEnumerable<T>> FunctionalPermutations<T>(IEnumerable<T> elements, int length)
    {
        if (length < 2) return elements.Select(t => new T[] { t });
        /* Pengyang answser..
          return _recur_(list, length - 1).SelectMany(t => list.Where(e => !t.Contains(e)),(t1, t2) => t1.Concat(new T[] { t2 }));
        */
        return elements.SelectMany((element_i, i) => 
          FunctionalPermutations(elements.Take(i).Concat(elements.Skip(i + 1)), length - 1)
            .Select(sub_ei => new[] { element_i }.Concat(sub_ei)));
    }

Надеюсь, этого хватит:

using System;
                
public class Program
{
    public static void Main()
    {
        //Example using word cat
        permute("cat");
    
    }

static void permute(string word){
    for(int i=0; i < word.Length; i++){
        char start = word[0];
        for(int j=1; j < word.Length; j++){
            string left = word.Substring(1,j-1);
            string right = word.Substring(j);
            Console.WriteLine(start+right+left);
        }
        if(i+1 < word.Length){
            word = wordChange(word, i + 1);
        }
            
    }
}

static string wordChange(string word, int index){
    string newWord = "";
    for(int i=0; i<word.Length; i++){
        if(i== 0)
            newWord += word[index];
        else if(i== index)
            newWord += word[0];
        else
            newWord += word[i];
    }
    return newWord;
}

вывод:

cat
cta
act
atc
tca
tac