Haskell, генерирующий все комбинации из n чисел

мой другого ответа дал арифметический алгоритм для перечисления всех комбинаций цифр. Вот альтернативное решение, которое возникает, обобщая ваш пример. Он также работает для не-чисел, потому что он использует только структуру списков.

во-первых, давайте напомним себе, как вы могли бы использовать понимание списка для трехзначных комбинаций.

threeDigitCombinations = [[x, y, z] | x <- [0..9], y <- [0..9], z <- [0..9]]

что здесь происходит? Понимание списка соответствует вложенным циклам. z отсчет от 0 до 9, тогда y идет до 1 и z снова начинает отсчет с 0. x тикает медленнее. Как вы заметили, форма понимания списка изменяется (хотя и единообразно), когда вы хотите другое количество цифр. Мы будем использовать это единообразие.

twoDigitCombinations = [[x, y] | x <- [0..9], y <- [0..9]]

мы хотим абстрагироваться от количества переменных в понимании списка (эквивалентно вложенности цикла). Давай поиграем с ним. Во-первых, я переписать этот список понятий как их эквивалент выделения монады.

threeDigitCombinations = do
    x <- [0..9]
    y <- [0..9]
    z <- [0..9]
    return [x, y, z]
twoDigitCombinations = do
    x <- [0..9]
    y <- [0..9]
    return [x, y]

интересные. Похоже на threeDigitCombinations это примерно то же монадическое действие, что и twoDigitCombinations, но с дополнительным заявлением. Снова переписываю...

zeroDigitCombinations = [[]]  -- equivalently, `return []`
oneDigitCombinations = do
    z <- [0..9]
    empty <- zeroDigitCombinations
    return (z : empty)
twoDigitCombinations = do
    y <- [0..9]
    z <- oneDigitCombinations
    return (y : z)
threeDigitCombinations = do
    x <- [0..9]
    yz <- twoDigitCombinations
    return (x : yz)

теперь должно быть ясно, что нам нужно параметризовать:

combinationsOfDigits 0 = return []
combinationsOfDigits n = do
    x <- [0..9]
    xs <- combinationsOfDigits (n - 1)
    return (x : xs)

ghci> combinationsOfDigits' 2
[[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9],[1,0],[1,1] ... [9,8],[9,9]]

это работает, но мы еще не закончили. Я хочу показать вам, что это пример более общей монадической модели. Сначала я собираюсь изменить реализацию combinationsOfDigits так что он складывает список констант.

combinationsOfDigits n = foldUpList $ replicate n [0..9]
    where foldUpList [] = return []
          foldUpList (xs : xss) = do
              x <- xs
              ys <- foldUpList xss
              return (x : ys)

глядя на определение foldUpList :: [[a]] -> [[a]], мы видим, что это на самом деле не требуют использования списки per se: он использует только монадные части списков. Это может работать на любой монаде, и это действительно так! Он находится в стандартной библиотеке и называется sequence :: Monad m => [m a] -> m [a]. Если вы смущены этим, замените m С [] и вы должны увидеть что эти типы означают одно и то же.

combinationsOfDigits n = sequence $ replicate n [0..9]

наконец, заметив, что sequence . replicate n определение replicateM, мы сводим его к очень быстрому однострочному.

combinationsOfDigits n = replicateM n [0..9]

таким образом, replicateM n дает n-ary комбинации входного списка. Это работает для любого списка, а не только для списка чисел. Действительно, он работает для любой монады - хотя интерпретация "комбинаций" имеет смысл только тогда, когда ваша монада представляет выбор.

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

С другой стороны, он работает намного быстрее, чем версия с числом. На моем (High-spec) MacBook Pro, скомпилированном с -O2, эта версия вычисляет 5-значные комбинации примерно в 4 раза быстрее, чем версия, которая хрустит цифры. (Если кто-нибудь может объяснить причину этого, я слушаю!)

combos 1 list = map (\x -> [x]) list
combos n list = foldl (++) [] $ map (\x -> map (\y -> x:y) nxt) list
    where nxt = combos (n-1) list

в вашем случае

combos 3 [0..9]