Find the missing permutation: Difference between revisions

{{task}}

 

 

=={{header|AutoHotkey}}==

 

CompleteList := Perm( "ABCD" )

}

return substr(L, 1, -1)

 

 

 

 

 

 

 

 

 

 

 

 

 

{

 

 

 

 

 

 

 

=={{header|C sharp|C#}}==

{{works with|C sharp|C#|2+}}

using System.Collections.Generic;

 

}

}

=={{header|Clojure}}==

(use 'clojure.set)

 

(def s1 (apply hash-set (permutations "ABCD")))

(def missing (difference s1 given))

=={{header|D}}==

 

 

}

 

 

 

 

=={{header|Fortran}}==

'''Work-around''' to let it run properly with some bugged versions (e.g. 4.3.2) of gfortran: remove the ''parameter'' attribute to the array list.

 

implicit none

write (*, *)

 

<pre>DBAC</pre>

 

=={{header|Haskell}}==

 

deficientPermsList =

 

 

 

procedure main()

write("The difference is : ")

every write(!givens, " ")

 

The approach above generates a full set of permutations and calculates the difference. Changing the two commented lines to the three below will calculate on the fly and would be more efficient for larger data sets.

 

if member(givens,x) then delete(givens,x) # remove givens as they are generated

 

procedure main()

if not member(givens, p) then write(p)

 

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/strings.icn member 'strings' provides permutes(s) which generates all permutations of a string]

 

=={{header|J}}==

'''Solution:'''

'''Use:'''

<pre>data=: >;: 'ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA'

Or the above could be a single definition that works the same way:

 

 

Or the equivalent explicit (cf. tacit above) definition:

item=. {. y

y -.~ item A.~ i.! #item

 

Or, the solution could be obtained without defining an independent program:

 

 

Here, <code>'ABCD'</code> represents the values being permuted (their order does not matter), and <code>4</code> is how many of them we have.

Yet another alternative expression, which uses parentheses instead of the [http://www.jsoftware.com/help/dictionary/d220v.htm passive operator] (<code>~</code>), would be:

 

 

=={{header|JavaScript}}==

The permute() function taken from http://snippets.dzone.com/posts/show/1032

for(var p = -1, j, k, f, r, l = v.length, q = 1, i = l + 1; --i; q *= i);

for(x = [new Array(l), new Array(l), new Array(l), new Array(l)], j = q, k = l + 1, i = -1;

 

missing = all.filter(function(elem) {return list.indexOf(elem) == -1});

 

=={{header|MATLAB}}==

This solution is designed to work on a column vector of strings. This will not work with a cell array or row vector of strings.

 

 

permsList = perms(list(1,:)); %Generate all permutations of the 4 letters

end %for

 

'CABD';

'ACDB';

ans =

 

 

 

=={{header|OCaml}}==

 

some utility functions:

| [] -> [[x]]

 

(* list of all permutations of li *)

 

(* convert a string to a char list *)

(* convert a char list to a string *)

let string_of_chars cl =

 

resolve the task:

 

"ABCD";"CABD";"ACDB";"DACB";

"BCDA";"ACBD";"ADCB";"CDAB";

let results = List.filter (fun v -> not(List.mem v deficient_perms)) perms

 

 

 

=={{header|Oz}}==

Using constraint programming for this problem may be a bit overkill...

GivenPermutations =

["ABCD" "CABD" "ACDB" "DACB" "BCDA" "ACBD" "ADCB" "CDAB" "DABC" "BCAD" "CADB" "CDBA"

{System.showInfo "Missing: "#P}

end

=={{header|PHP}}==

$finalres = Array();

function permut($arr,$result=array()){

permut($given);

print_r(array_diff($finalres,$givenPerms)); // Array ( [20] => DBAC )

 

 

 

 

=={{header|PicoLisp}}==

(mapcar chop

(quote

(rot L) )

(unless (member Lst *PermList) # Check

<pre>DBAC</pre>

 

=={{header|PureBasic}}==

Define.i i, j

Define.s a

Data.s "DABC","BCAD","CADB","CDBA","CBAD","ABDC","ADBC","BDCA"

Data.s "DCBA","BACD","BADC","BDAC","CBDA","DBCA","DCAB"

 

 

=={{header|Python}}==

{{works with|Python|2.6+}}

 

given = '''ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA

allPerms = [''.join(x) for x in permutations(given[0])]

 

 

=={{header|R}}==

This uses the "combinat" package, which is a standard R package:

library(combinat)

 

 

setdiff(perms3, incomplete)

 

[1] "DBAC"

 

=={{header|Ruby}}==

ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA

CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB

}

 

 

 

=={{header|Scala}}==

{{works with|Scala|2.8}}

def perm[A](x: Int, a: Seq[A]): Seq[A] = if (x == 0) a else {

val n = a.size

DBCA

DCAB""".stripMargin.split("\n")

 

 

 

 

}

}

 

}

 

}

 

=={{header|Ursala}}==

The permutation generating function is imported from the standard library below

comparison with other solutions.

The <code>~&j</code> operator computes set differences.

#show+

 

CBDA

DBCA

<pre>

DBAC

</pre>