Permutations/Derangements: Difference between revisions

Content added Content deleted

Inline

@@ Line 307: / Line 307: @@
 !12=   176214841
 </pre>
 =={{header|Ada}}==
@@ Line 513: / Line 512: @@
 Approximation of !20: 895014631192902144</pre>
 =={{header|BBC BASIC}}==
 {{works with|BBC BASIC for Windows}}
@@ Line 1,454: / Line 1,454: @@
 #   [       8,   14833,   14833,   14833 ],
 #   [       9,  133496,  133496,  133496 ] ]</lang>
 =={{header|Go}}==
 <lang go>package main
@@ Line 2,360: / Line 2,361: @@
 895014631192902121
 290131015521620609254546237518688936375622413566095185632876940298382875066633305125595907908697818551860745708196640009079772455670451355426573609799907339222509103785567575227183775791345718826220455840965346196540544976439608810006794385963854831693077054723298130736781093200499800934036993104223443563872463385599425635345341317933466521378117877578807421014599223577201
-</pre>
-=={{header|Perl 6}}==
-{{trans|Perl}}
-{{works with|Rakudo|2016.10}}
-Generate <code>List.permutations</code> and keep the ones where no elements are in their original position. This is done by zipping each permutation with the original list, and keeping the ones where none of the zipped pairs are equal.
-I am using the <code>Z</code> infix zip operator with the <code>eqv</code> equivalence infix operator, all wrapped inside a <code>none()</code> Junction.
-Although not necessary for this task, I have used <code>eqv</code> instead of <code>==</code> so that the <code>derangements()</code> function also works with any set of arbitrary objects (eg. strings, lists, etc.)
-<lang perl6>sub derangements(@l) {
-    @l.permutations.grep(-> @p { none(@p Zeqv @l) })
-}
-sub prefix:<!>(Int $n) {
-    (1, 0, 1, -> $a, $b { ($++ + 2) × ($b + $a) } ... *)[$n]
-}
-say 'derangements([1, 2, 3, 4])';
-say derangements([1, 2, 3, 4]), "\n";
-say 'n == !n == derangements(^n).elems';
-for 0 .. 9 -> $n {
-    say "!$n == { !$n } == { derangements(^$n).elems }"
-}</lang>
-{{out}}
-<pre>
-derangements([1, 2, 3, 4])
-((2 1 4 3) (2 3 4 1) (2 4 1 3) (3 1 4 2) (3 4 1 2) (3 4 2 1) (4 1 2 3) (4 3 1 2) (4 3 2 1))
-n == !n == derangements(^n).elems
-!0 == 1 == 1
-!1 == 0 == 0
-!2 == 1 == 1
-!3 == 2 == 2
-!4 == 9 == 9
-!5 == 44 == 44
-!6 == 265 == 265
-!7 == 1854 == 1854
-!8 == 14833 == 14833
-!9 == 133496 == 133496
 </pre>
@@ Line 2,908: / Line 2,864: @@
 ;; -> 895014631192902121
 </lang>
+=={{header|Raku}}==
+(formerly Perl 6)
+{{trans|Perl}}
+{{works with|Rakudo|2016.10}}
+Generate <code>List.permutations</code> and keep the ones where no elements are in their original position. This is done by zipping each permutation with the original list, and keeping the ones where none of the zipped pairs are equal.
+I am using the <code>Z</code> infix zip operator with the <code>eqv</code> equivalence infix operator, all wrapped inside a <code>none()</code> Junction.
+Although not necessary for this task, I have used <code>eqv</code> instead of <code>==</code> so that the <code>derangements()</code> function also works with any set of arbitrary objects (eg. strings, lists, etc.)
+<lang perl6>sub derangements(@l) {
+    @l.permutations.grep(-> @p { none(@p Zeqv @l) })
+}
+sub prefix:<!>(Int $n) {
+    (1, 0, 1, -> $a, $b { ($++ + 2) × ($b + $a) } ... *)[$n]
+}
+say 'derangements([1, 2, 3, 4])';
+say derangements([1, 2, 3, 4]), "\n";
+say 'n == !n == derangements(^n).elems';
+for 0 .. 9 -> $n {
+    say "!$n == { !$n } == { derangements(^$n).elems }"
+}</lang>
+{{out}}
+<pre>
+derangements([1, 2, 3, 4])
+((2 1 4 3) (2 3 4 1) (2 4 1 3) (3 1 4 2) (3 4 1 2) (3 4 2 1) (4 1 2 3) (4 3 1 2) (4 3 2 1))
+n == !n == derangements(^n).elems
+!0 == 1 == 1
+!1 == 0 == 0
+!2 == 1 == 1
+!3 == 2 == 2
+!4 == 9 == 9
+!5 == 44 == 44
+!6 == 265 == 265
+!7 == 1854 == 1854
+!8 == 14833 == 14833
+!9 == 133496 == 133496
+</pre>
 =={{header|REXX}}==