Найдите все комбинации данного набора чисел

import Data.List (inits, tails)

place :: a -> [a] -> [[a]]
place element list = zipWith (\front back -> front ++ element:back)
                             (inits list)
                             (tails list)

perm :: [a] -> [[a]]
perm = foldr (\element rest -> concat (map (place element) rest)) [[]]

test = perm [1, 3, 14]

Мне кажется, что вы ищете все перестановки заданного набора элементов.

Если Вы используете C++, то существует стандартная функция next_permutation(), которая делает именно то, что Вы ищете. Вы начинаете с отсортированного массива и затем повторно вызываете next_permutation.

Пример здесь: http://www.cplusplus.com/reference/algorithm/next_permutation/

Вы ищете все перестановки заданного набора значений.

Одна статья о "выполнении" перестановок в Java находится здесь: http://www.bearcave.com/random_hacks/permute.html

Вы хотите пропустить первые пару разделов, пока не перейдете к заголовку Алгоритмы перестановки (конечно).

Вот моя реализация перестановки на C# 3.0, которую вы можете найти полезную

public static class PermutationExpressions
    {
        public static IEnumerable<IEnumerable<T>> Permutations<T>(this IEnumerable<T> list)
        {
            return list.Permutations((uint)list.Count());
        }

        public static IEnumerable<IEnumerable<T>> Permutations<T>(this IList<T> list)
        {
            return list.Permutations((uint)list.Count);
        }

        private static IEnumerable<IEnumerable<T>> Permutations<T>(this IEnumerable<T> list, uint n)
        {
            if (n < 2) yield return list;
            else
            {
                var ie = list.GetEnumerator();
                for (var i = 0; i < n; i++)
                {
                    ie.MoveNext();
                    var item = ie.Current;

                    var i1 = i;
                    var sub_list = list.Where((excluded, j) => j != i1).ToList();

                    var sub_permutations = sub_list.Permutations(n - 1);

                    foreach (var sub_permutation in sub_permutations)
                    {
                        yield return
                            Enumerable.Repeat(item, 1)
                                .Concat(sub_permutation);
                    }
                }
            }
        }
        }

[TestFixture]
    public class TestPermutations
    {
        [Test]
        public void Permutation_Returns_Permutations()
        {
            var permutations = PermutationExpressions.Permutations(new[] { "a", "b", "c" }.AsEnumerable());
            foreach (var permutation in permutations)
            {
                Console.WriteLine(string.Join("", permutation.ToArray()));
            }
            Assert.AreEqual("abc_acb_bac_bca_cab_cba", permutations.Select(perm => perm.joinToString("")).joinToString("_"));
        }
    }

Ничего общего с динамическим программированием, если только вы не хотите носить трусы за пределами брюк и рисовать символ на груди.

Простой способ сделать это - поддерживать массив из 0-9 целых чисел, затем прогонять числа один за другим и инкрементировать массив [число]. В результате, после обработки всех цифр, вы увидите, является ли какой-либо элемент массива ненулевым или единичным. (Это указывает на повторяющуюся цифру.) Конечно, тривиально взять число, а затем пройти через цифру за цифрой, используя модуль и делитель.

Итак, допустим, у вас есть числа 1, 2 и 3.

Если вы ожидаете, что шесть чисел 123, 132, 213, 231, 312 и 321 будут правильным ответом, то вам нужен какой-нибудь код для генерации всех перестановок множества, который будет быстрее, чем почти все остальное для задач интересного размера. Впрочем, вы смотрите на O(n!) как на лучший вариант.

Нужно написать рекурсивную функцию, которая циклически перебирает список и каждый раз вызывает себя с обновленным списком. Это означает, что для перехода к следующей итерации необходимо создать копию списка с элементами N-1. Для получения результата необходимо добавлять текущий выбранный номер в каждой итерации.

string Permutations(List numbers, string prefix)
{
   foreach (current_number in numbers)
   {
      new_prefix = prefix+"-"+number;
      new_list=make_copy_except(numbers,  current_number)
      if (new_list.Length==0)
           print new_prefix
      else
           Permutations(new_list, new_prefix)
   }
}