Permutations: Difference between revisions

Content added Content deleted

Inline

@@ Line 6,262: / Line 6,262: @@
 [3, 2, 1]
 </pre>
-===Single yield iterator===
-The output order is same as standard Heap's algorithm.
-<lang nim>
-iterator permutations[T](lis: var seq[T]): var seq[T] =
-  var
-    js = newSeq[int](max(2, lis.len))
-    i = 1
-  while true:
-    while js[i] <= i:
-        i -= 1
-        js[i] = 0
-        if i == 0:
-          yield lis
-          break
-    i += 1
-    if i >= lis.len: break
-    let k = if (i and 1) == 0: 0 else: js[i]
-    swap lis[i], lis[k]
-    js[i] += 1
-</lang>
 ===Translation of C===
@@ Line 6,289: / Line 6,268: @@
 iterator permutations[T](ys: openarray[T]): seq[T] =
   var
-    d = 1
+    d = 0
-    c = newSeq[int](ys.len)
+    c = newSeq[int](max(1, ys.len))
     xs = newSeq[T](ys.len)
   for i, y in ys: xs[i] = y
-  yield xs
   block outer:
     while true:
-      while d > 1:
+      while d > 0:
         dec d
         c[d] = 0
+      yield xs
       while c[d] >= d:
         inc d
         if d >= ys.len: break outer
       let i = if (d and 1) == 1: c[d] else: 0
       swap xs[i], xs[d]
-      yield xs
       inc c[d]