Question

在哪里可以找到Recaman序列的递归算法？发布的所有算法都是迭代类型。语言并不重要。

Answer 1

这是Python的解决方案：

def rec(x):
       if x == 1:
           list.append(x)
           return x
       else:
           a = rec(x-1)
           am = a - x
           ap = a + x
           if am > 0 and am not in list:
               list.append(am)
               return am
           else:
               list.append(ap)
               return ap
list=[]
return rec(x)

Answer 2

我个人觉得这个问题本身很有趣。

首先，Python中的纯（即。没有副作用）递归实现：

def recaman_sequence(n):
    def recurs(seen, i, term):
        if i > n:
            return []
        elif term > i and term - i not in seen:
            return [term - i] + recurs(seen.union({term - i}), i + 1, term - i)
        else:
            return [term + i] + recurs(seen.union({term + i}), i + 1, term + i)
    return recurs(set(), 1, 0)

在具有尾调用优化的语言中，如OCaml，可以更快地实现这些：

let recaman_sequence n =
    let rec urs i = function
        | [] -> urs (i + 1) [1]
        | terms when i > n -> List.rev terms
        | term::tail as terms when term > i && not (List.mem (term - i) tail) -> urs (i + 1) ((term - i)::terms)
        | term::tail as terms -> urs (i + 1) ((term + i)::terms)
    in urs 1 []
;;

但请注意List.mem是O（n）。更高级的版本将在O（log n）或O（1）中使用带有此操作的分离累加器（如Python中的set）。

OEIS在Haskell中有这样的版本（由于Reinhard Zumkeller，2011年3月14日），非常易读，但同样不是尾递归的：

import Data.Set (Set, singleton, notMember, insert)
a005132 n = a005132_list !! n
a005132_list = 0 : recaman (singleton 0) 1 0 where
   recaman :: Set Integer -> Integer -> Integer -> [Integer]
   recaman s n x = if x > n && (x - n) `notMember` s
                      then (x-n) : recaman (insert (x-n) s) (n+1) (x-n)
                      else (x+n) : recaman (insert (x+n) s) (n+1) (x+n)

Answer 3

在方案中，您可以使用

UserSchedule

计算系列。这是书面的递归（但效率低且非常不优雅）。

Recaman的序列递归算法

3 个答案: