A-M baby
This commit is contained in:
Ingy döt Net
parent
764da6cbbb
commit
db842d013d
19005 changed files with 197040 additions and 7 deletions
29
Task/Find-the-missing-permutation/0DESCRIPTION
Normal file
29
Task/Find-the-missing-permutation/0DESCRIPTION
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
These are all of the permutations of the symbols A, B, C and D, except for one that's not listed. Find that missing permutation.
|
||||
|
||||
(cf. [[Permutations]])
|
||||
|
||||
There is an obvious method : enumerating all permutations of A, B, C, D, and looking for the missing one. There is an alternate method. Hint : if all permutations were here, how many times would A appear in each position ? What is the parity of this number ?
|
||||
|
||||
<pre>ABCD
|
||||
CABD
|
||||
ACDB
|
||||
DACB
|
||||
BCDA
|
||||
ACBD
|
||||
ADCB
|
||||
CDAB
|
||||
DABC
|
||||
BCAD
|
||||
CADB
|
||||
CDBA
|
||||
CBAD
|
||||
ABDC
|
||||
ADBC
|
||||
BDCA
|
||||
DCBA
|
||||
BACD
|
||||
BADC
|
||||
BDAC
|
||||
CBDA
|
||||
DBCA
|
||||
DCAB</pre>
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
with Ada.Text_IO;
|
||||
procedure Missing_Permutations is
|
||||
subtype Permutation_Character is Character range 'A' .. 'D';
|
||||
|
||||
Character_Count : constant :=
|
||||
1 + Permutation_Character'Pos (Permutation_Character'Last)
|
||||
- Permutation_Character'Pos (Permutation_Character'First);
|
||||
|
||||
type Permutation_String is
|
||||
array (1 .. Character_Count) of Permutation_Character;
|
||||
|
||||
procedure Put (Item : Permutation_String) is
|
||||
begin
|
||||
for I in Item'Range loop
|
||||
Ada.Text_IO.Put (Item (I));
|
||||
end loop;
|
||||
end Put;
|
||||
|
||||
Given_Permutations : array (Positive range <>) of Permutation_String :=
|
||||
("ABCD", "CABD", "ACDB", "DACB", "BCDA", "ACBD",
|
||||
"ADCB", "CDAB", "DABC", "BCAD", "CADB", "CDBA",
|
||||
"CBAD", "ABDC", "ADBC", "BDCA", "DCBA", "BACD",
|
||||
"BADC", "BDAC", "CBDA", "DBCA", "DCAB");
|
||||
|
||||
Count : array (Permutation_Character, 1 .. Character_Count) of Natural
|
||||
:= (others => (others => 0));
|
||||
Max_Count : Positive := 1;
|
||||
|
||||
Missing_Permutation : Permutation_String;
|
||||
begin
|
||||
for I in Given_Permutations'Range loop
|
||||
for Pos in 1 .. Character_Count loop
|
||||
Count (Given_Permutations (I) (Pos), Pos) :=
|
||||
Count (Given_Permutations (I) (Pos), Pos) + 1;
|
||||
if Count (Given_Permutations (I) (Pos), Pos) > Max_Count then
|
||||
Max_Count := Count (Given_Permutations (I) (Pos), Pos);
|
||||
end if;
|
||||
end loop;
|
||||
end loop;
|
||||
|
||||
for Char in Permutation_Character loop
|
||||
for Pos in 1 .. Character_Count loop
|
||||
if Count (Char, Pos) < Max_Count then
|
||||
Missing_Permutation (Pos) := Char;
|
||||
end if;
|
||||
end loop;
|
||||
end loop;
|
||||
|
||||
Ada.Text_IO.Put_Line ("Missing Permutation:");
|
||||
Put (Missing_Permutation);
|
||||
end Missing_Permutations;
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
IncompleteList := "ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB"
|
||||
|
||||
CompleteList := Perm( "ABCD" )
|
||||
Missing := ""
|
||||
|
||||
Loop, Parse, CompleteList, `n, `r
|
||||
If !InStr( IncompleteList , A_LoopField )
|
||||
Missing .= "`n" A_LoopField
|
||||
|
||||
MsgBox Missing Permutation(s):%Missing%
|
||||
|
||||
;-------------------------------------------------
|
||||
|
||||
; Shortened version of [VxE]'s permutation function
|
||||
; http://www.autohotkey.com/forum/post-322251.html#322251
|
||||
Perm( s , dL="" , t="" , p="") {
|
||||
StringSplit, m, s, % d := SubStr(dL,1,1) , %t%
|
||||
IfEqual, m0, 1, return m1 d p
|
||||
Loop %m0%
|
||||
{
|
||||
r := m1
|
||||
Loop % m0-2
|
||||
x := A_Index + 1, r .= d m%x%
|
||||
L .= Perm(r, d, t, m%m0% d p)"`n" , mx := m1
|
||||
Loop % m0-1
|
||||
x := A_Index + 1, m%A_Index% := m%x%
|
||||
m%m0% := mx
|
||||
}
|
||||
return substr(L, 1, -1)
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
DIM perms$(22), miss&(4)
|
||||
perms$() = "ABCD", "CABD", "ACDB", "DACB", "BCDA", "ACBD", "ADCB", \
|
||||
\ "CDAB", "DABC", "BCAD", "CADB", "CDBA", "CBAD", "ABDC", "ADBC", \
|
||||
\ "BDCA", "DCBA", "BACD", "BADC", "BDAC", "CBDA", "DBCA", "DCAB"
|
||||
|
||||
FOR i% = 0 TO DIM(perms$(),1)
|
||||
FOR j% = 1 TO DIM(miss&(),1)
|
||||
miss&(j%-1) EOR= ASCMID$(perms$(i%),j%)
|
||||
NEXT
|
||||
NEXT
|
||||
PRINT $$^miss&(0) " is missing"
|
||||
END
|
||||
|
|
@ -0,0 +1 @@
|
|||
ln"ABCD"r@\/\\
|
||||
|
|
@ -0,0 +1 @@
|
|||
ln)XXtp)><)F:)<]u[/v\[
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <iterator>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
static const std::string GivenPermutations[] = {
|
||||
"ABCD","CABD","ACDB","DACB",
|
||||
"BCDA","ACBD","ADCB","CDAB",
|
||||
"DABC","BCAD","CADB","CDBA",
|
||||
"CBAD","ABDC","ADBC","BDCA",
|
||||
"DCBA","BACD","BADC","BDAC",
|
||||
"CBDA","DBCA","DCAB"
|
||||
};
|
||||
static const size_t NumGivenPermutations = sizeof(GivenPermutations) / sizeof(*GivenPermutations);
|
||||
|
||||
int main()
|
||||
{
|
||||
std::vector<std::string> permutations;
|
||||
std::string initial = "ABCD";
|
||||
permutations.push_back(initial);
|
||||
|
||||
while(true)
|
||||
{
|
||||
std::string p = permutations.back();
|
||||
std::next_permutation(p.begin(), p.end());
|
||||
if(p == permutations.front())
|
||||
break;
|
||||
permutations.push_back(p);
|
||||
}
|
||||
|
||||
std::vector<std::string> missing;
|
||||
std::set<std::string> given_permutations(GivenPermutations, GivenPermutations + NumGivenPermutations);
|
||||
std::set_difference(permutations.begin(), permutations.end(), given_permutations.begin(),
|
||||
given_permutations.end(), std::back_inserter(missing));
|
||||
std::copy(missing.begin(), missing.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include <stdio.h>
|
||||
|
||||
#define N 4
|
||||
const char *perms[] = {
|
||||
"ABCD", "CABD", "ACDB", "DACB", "BCDA", "ACBD", "ADCB", "CDAB",
|
||||
"DABC", "BCAD", "CADB", "CDBA", "CBAD", "ABDC", "ADBC", "BDCA",
|
||||
"DCBA", "BACD", "BADC", "BDAC", "CBDA", "DBCA", "DCAB",
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
int i, j, n, cnt[N];
|
||||
char miss[N];
|
||||
|
||||
for (n = i = 1; i < N; i++) n *= i; /* n = (N-1)!, # of occurrence */
|
||||
|
||||
for (i = 0; i < N; i++) {
|
||||
for (j = 0; j < N; j++) cnt[j] = 0;
|
||||
|
||||
/* count how many times each letter occur at position i */
|
||||
for (j = 0; j < sizeof(perms)/sizeof(const char*); j++)
|
||||
cnt[perms[j][i] - 'A']++;
|
||||
|
||||
/* letter not occurring (N-1)! times is the missing one */
|
||||
for (j = 0; j < N && cnt[j] == n; j++);
|
||||
|
||||
miss[i] = j + 'A';
|
||||
}
|
||||
printf("Missing: %.*s\n", N, miss);
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
(use 'clojure.contrib.combinatorics)
|
||||
(use 'clojure.set)
|
||||
|
||||
(def given (apply hash-set (partition 4 5 "ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB" )))
|
||||
(def s1 (apply hash-set (permutations "ABCD")))
|
||||
(def missing (difference s1 given))
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
missing_permutation = (arr) ->
|
||||
# Find the missing permutation in an array of N! - 1 permutations.
|
||||
|
||||
# We won't validate every precondition, but we do have some basic
|
||||
# guards.
|
||||
if arr.length == 0
|
||||
throw Error "Need more data"
|
||||
if arr.length == 1
|
||||
return [arr[0][1] + arr[0][0]]
|
||||
|
||||
# Now we know that for each position in the string, elements should appear
|
||||
# an even number of times (N-1 >= 2). We can use a set to detect the element appearing
|
||||
# an odd number of times. Detect odd occurrences by toggling admission/expulsion
|
||||
# to and from the set for each value encountered. At the end of each pass one element
|
||||
# will remain in the set.
|
||||
result = ''
|
||||
for pos in [0...arr[0].length]
|
||||
set = {}
|
||||
for permutation in arr
|
||||
c = permutation[pos]
|
||||
if set[c]
|
||||
delete set[c]
|
||||
else
|
||||
set[c] = true
|
||||
for c of set
|
||||
result += c
|
||||
break
|
||||
result
|
||||
|
||||
given = '''ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA
|
||||
CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB'''
|
||||
|
||||
arr = (s for s in given.replace('\n', ' ').split ' ' when s != '')
|
||||
|
||||
console.log missing_permutation(arr)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
> coffee missing_permute.coffee
|
||||
DBAC
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
(defparameter *permutations*
|
||||
'("ABCD" "CABD" "ACDB" "DACB" "BCDA" "ACBD" "ADCB" "CDAB" "DABC" "BCAD" "CADB" "CDBA"
|
||||
"CBAD" "ABDC" "ADBC" "BDCA" "DCBA" "BACD" "BADC" "BDAC" "CBDA" "DBCA" "DCAB"))
|
||||
|
||||
(defun missing-perm (perms)
|
||||
(let* ((letters (loop for i across (car perms) collecting i))
|
||||
(l (/ (1+ (length perms)) (length letters))))
|
||||
(labels ((enum (n) (loop for i below n collecting i))
|
||||
(least-occurs (pos)
|
||||
(let ((occurs (loop for i in perms collecting (aref i pos))))
|
||||
(cdr (assoc (1- l) (mapcar #'(lambda (letter)
|
||||
(cons (count letter occurs) letter))
|
||||
letters))))))
|
||||
(concatenate 'string (mapcar #'least-occurs (enum (length letters)))))))
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
import std.stdio, std.string, std.algorithm, std.array, std.range;
|
||||
|
||||
void main() {
|
||||
const givenSet = "ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC
|
||||
BCAD CADB CDBA CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA
|
||||
DBCA DCAB"d.split().zip(repeat(true)).assocArray();
|
||||
|
||||
auto p = "ABCD"d.dup;
|
||||
do {
|
||||
if (p !in givenSet)
|
||||
writeln("Missing permutation: ", p);
|
||||
} while (p.nextPermutation());
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
import std.stdio, std.string, std.algorithm, std.conv;
|
||||
|
||||
void main() {
|
||||
const perms = "ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC
|
||||
BCAD CADB CDBA CBAD ABDC ADBC BDCA DCBA BACD
|
||||
BADC BDAC CBDA DBCA DCAB".split();
|
||||
|
||||
// Version 1: XOR all the ASCII values, the uneven one gets
|
||||
// flushed out; based on Perl 6 (via Go)
|
||||
ubyte[4] b;
|
||||
foreach (perm; perms)
|
||||
foreach (i, c; perm)
|
||||
b[i] ^= c;
|
||||
writeln(cast(char[])b);
|
||||
|
||||
// Version 2 : Sum ASCII values
|
||||
auto sumr = perms[0].reduce!q{a + b}(); // sum row
|
||||
foreach (i; 0 .. 4) {
|
||||
// sum columns
|
||||
const sumc = reduce!((a,b)=> text(to!int(a) + b[i]))("0",perms);
|
||||
// see how much it falls short
|
||||
write(cast(char)(sumr - to!int(sumc) % sumr));
|
||||
}
|
||||
writeln();
|
||||
|
||||
// Version 3: some sort of checksum, don't ask
|
||||
// me: translation of Java
|
||||
enum int len = 4;
|
||||
int maxCode = len - 1;
|
||||
foreach_reverse (i; 3 .. len + 1)
|
||||
maxCode *= i; // maxCode will be 36
|
||||
foreach (i; 0 .. len) {
|
||||
int code = 0;
|
||||
foreach (p; perms)
|
||||
code += perms[0].countUntil(p[i]);
|
||||
|
||||
// code will come up 3, 1, 0, 2 short of 36
|
||||
write(cast(char)perms[0][maxCode - code]);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
program missing_permutation
|
||||
|
||||
implicit none
|
||||
character (4), dimension (23), parameter :: list = &
|
||||
& (/'ABCD', 'CABD', 'ACDB', 'DACB', 'BCDA', 'ACBD', 'ADCB', 'CDAB', &
|
||||
& 'DABC', 'BCAD', 'CADB', 'CDBA', 'CBAD', 'ABDC', 'ADBC', 'BDCA', &
|
||||
& 'DCBA', 'BACD', 'BADC', 'BDAC', 'CBDA', 'DBCA', 'DCAB'/)
|
||||
integer :: i, j, k
|
||||
|
||||
do i = 1, 4
|
||||
j = minloc ((/(count (list (:) (i : i) == list (1) (k : k)), k = 1, 4)/), 1)
|
||||
write (*, '(a)', advance = 'no') list (1) (j : j)
|
||||
end do
|
||||
write (*, *)
|
||||
|
||||
end program missing_permutation
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
# our deficient list
|
||||
L :=
|
||||
[ "ABCD", "CABD", "ACDB", "DACB", "BCDA",
|
||||
"ACBD", "ADCB", "CDAB", "DABC", "BCAD",
|
||||
"CADB", "CDBA", "CBAD", "ABDC", "ADBC",
|
||||
"BDCA", "DCBA", "BACD", "BADC", "BDAC",
|
||||
"CBDA", "DBCA", "DCAB" ];
|
||||
|
||||
# convert L to permutations on 1..4
|
||||
u := List(L, s -> List([1..4], i -> Position("ABCD", s[i])));
|
||||
|
||||
# set difference (with all permutations)
|
||||
v := Difference(PermutationsList([1..4]), u);
|
||||
|
||||
# convert back to letters
|
||||
s := "ABCD";
|
||||
List(v, p -> List(p, i -> s[i]));
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var given = strings.Split(`ABCD
|
||||
CABD
|
||||
ACDB
|
||||
DACB
|
||||
BCDA
|
||||
ACBD
|
||||
ADCB
|
||||
CDAB
|
||||
DABC
|
||||
BCAD
|
||||
CADB
|
||||
CDBA
|
||||
CBAD
|
||||
ABDC
|
||||
ADBC
|
||||
BDCA
|
||||
DCBA
|
||||
BACD
|
||||
BADC
|
||||
BDAC
|
||||
CBDA
|
||||
DBCA
|
||||
DCAB`, "\n")
|
||||
|
||||
func main() {
|
||||
b := make([]byte, len(given[0]))
|
||||
for i := range b {
|
||||
m := make(map[byte]int)
|
||||
for _, p := range given {
|
||||
m[p[i]]++
|
||||
}
|
||||
for char, count := range m {
|
||||
if count&1 == 1 {
|
||||
b[i] = char
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
fmt.Println(string(b))
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
func main() {
|
||||
b := make([]byte, len(given[0]))
|
||||
for _, p := range given {
|
||||
for i, c := range []byte(p) {
|
||||
b[i] ^= c
|
||||
}
|
||||
}
|
||||
fmt.Println(string(b))
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
def fact = { n -> [1,(1..<(n+1)).inject(1) { prod, i -> prod * i }].max() }
|
||||
def missingPerms
|
||||
missingPerms = {List elts, List perms ->
|
||||
perms.empty ? elts.permutations() : elts.collect { e ->
|
||||
def ePerms = perms.findAll { e == it[0] }.collect { it[1..-1] }
|
||||
ePerms.size() == fact(elts.size() - 1) ? [] \
|
||||
: missingPerms(elts - e, ePerms).collect { [e] + it }
|
||||
}.sum()
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
def e = 'ABCD' as List
|
||||
def p = ['ABCD', 'CABD', 'ACDB', 'DACB', 'BCDA', 'ACBD', 'ADCB', 'CDAB', 'DABC', 'BCAD', 'CADB', 'CDBA',
|
||||
'CBAD', 'ABDC', 'ADBC', 'BDCA', 'DCBA', 'BACD', 'BADC', 'BDAC', 'CBDA', 'DBCA', 'DCAB'].collect { it as List }
|
||||
|
||||
def mp = missingPerms(e, p)
|
||||
mp.each { println it }
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
import Data.List
|
||||
import Control.Monad
|
||||
import Control.Arrow
|
||||
|
||||
missingPerm :: Eq a => [[a]] -> [[a]]
|
||||
missingPerm = (\\) =<< permutations . nub . join
|
||||
|
||||
deficientPermsList = ["ABCD","CABD","ACDB","DACB",
|
||||
"BCDA","ACBD","ADCB","CDAB",
|
||||
"DABC","BCAD","CADB","CDBA",
|
||||
"CBAD","ABDC","ADBC","BDCA",
|
||||
"DCBA","BACD","BADC","BDAC",
|
||||
"CBDA","DBCA","DCAB"]
|
||||
|
||||
main = do
|
||||
print $ missingPerm deficientPermsList
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
link strings # for permutes
|
||||
|
||||
procedure main()
|
||||
givens := set![ "ABCD", "CABD", "ACDB", "DACB", "BCDA", "ACBD", "ADCB", "CDAB", "DABC", "BCAD", "CADB",
|
||||
"CDBA", "CBAD", "ABDC", "ADBC", "BDCA", "DCBA", "BACD", "BADC", "BDAC", "CBDA", "DBCA", "DCAB"]
|
||||
|
||||
every insert(full := set(), permutes("ABCD")) # generate all permutations
|
||||
givens := full--givens # and difference
|
||||
|
||||
write("The difference is : ")
|
||||
every write(!givens, " ")
|
||||
end
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
every x := permutes("ABCD") do # generate all permutations
|
||||
if member(givens,x) then delete(givens,x) # remove givens as they are generated
|
||||
else insert(givens,x) # add back any not given
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
link strings
|
||||
|
||||
procedure main()
|
||||
givens := set("ABCD", "CABD", "ACDB", "DACB", "BCDA", "ACBD",
|
||||
"ADCB", "CDAB", "DABC", "BCAD", "CADB", "CDBA",
|
||||
"CBAD", "ABDC", "ADBC", "BDCA", "DCBA", "BACD",
|
||||
"BADC", "BDAC", "CBDA", "DBCA", "DCAB")
|
||||
|
||||
every p := permutes("ABCD") do
|
||||
if not member(givens, p) then write(p)
|
||||
|
||||
end
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
permutations=: A.~ i.@!@#
|
||||
missingPerms=: -.~ permutations @ {.
|
||||
|
|
@ -0,0 +1 @@
|
|||
missingPerms=: -.~ (A.~ i.@!@#) @ {.
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
missingPerms=: monad define
|
||||
item=. {. y
|
||||
y -.~ item A.~ i.! #item
|
||||
)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
data -.~ 'ABCD' A.~ i.!4
|
||||
DBAC
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
((i.!4) A. 'ABCD') -. data
|
||||
DBAC
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
import java.util.ArrayList;
|
||||
|
||||
import com.google.common.base.Joiner;
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.google.common.collect.Lists;
|
||||
|
||||
public class FindMissingPermutation {
|
||||
public static void main(String[] args) {
|
||||
Joiner joiner = Joiner.on("").skipNulls();
|
||||
ImmutableSet<String> s = ImmutableSet.of("ABCD", "CABD", "ACDB",
|
||||
"DACB", "BCDA", "ACBD", "ADCB", "CDAB", "DABC", "BCAD", "CADB",
|
||||
"CDBA", "CBAD", "ABDC", "ADBC", "BDCA", "DCBA", "BACD", "BADC",
|
||||
"BDAC", "CBDA", "DBCA", "DCAB");
|
||||
|
||||
for (ArrayList<Character> cs : Utils.Permutations(Lists.newArrayList(
|
||||
'A', 'B', 'C', 'D')))
|
||||
if (!s.contains(joiner.join(cs)))
|
||||
System.out.println(joiner.join(cs));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
public class FindMissingPermutation
|
||||
{
|
||||
public static void main(String[] args)
|
||||
{
|
||||
String[] givenPermutations = { "ABCD", "CABD", "ACDB", "DACB", "BCDA", "ACBD",
|
||||
"ADCB", "CDAB", "DABC", "BCAD", "CADB", "CDBA",
|
||||
"CBAD", "ABDC", "ADBC", "BDCA", "DCBA", "BACD",
|
||||
"BADC", "BDAC", "CBDA", "DBCA", "DCAB" };
|
||||
String characterSet = givenPermutations[0];
|
||||
// Compute n! * (n - 1) / 2
|
||||
int maxCode = characterSet.length() - 1;
|
||||
for (int i = characterSet.length(); i >= 3; i--)
|
||||
maxCode *= i;
|
||||
StringBuilder missingPermutation = new StringBuilder();
|
||||
for (int i = 0; i < characterSet.length(); i++)
|
||||
{
|
||||
int code = 0;
|
||||
for (String permutation : givenPermutations)
|
||||
code += characterSet.indexOf(permutation.charAt(i));
|
||||
missingPermutation.append(characterSet.charAt(maxCode - code));
|
||||
}
|
||||
System.out.println("Missing permutation: " + missingPermutation.toString());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
permute = function(v, m){ //v1.0
|
||||
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;
|
||||
++i < l; x[2][i] = i, x[1][i] = x[0][i] = j /= --k);
|
||||
for(r = new Array(q); ++p < q;)
|
||||
for(r[p] = new Array(l), i = -1; ++i < l; !--x[1][i] && (x[1][i] = x[0][i],
|
||||
x[2][i] = (x[2][i] + 1) % l), r[p][i] = m ? x[3][i] : v[x[3][i]])
|
||||
for(x[3][i] = x[2][i], f = 0; !f; f = !f)
|
||||
for(j = i; j; x[3][--j] == x[2][i] && (x[3][i] = x[2][i] = (x[2][i] + 1) % l, f = 1));
|
||||
return r;
|
||||
};
|
||||
|
||||
list = [ 'ABCD', 'CABD', 'ACDB', 'DACB', 'BCDA', 'ACBD', 'ADCB', 'CDAB',
|
||||
'DABC', 'BCAD', 'CADB', 'CDBA', 'CBAD', 'ABDC', 'ADBC', 'BDCA',
|
||||
'DCBA', 'BACD', 'BADC', 'BDAC', 'CBDA', 'DBCA', 'DCAB'];
|
||||
|
||||
all = permute(list[0].split('')).map(function(elem) {return elem.join('')});
|
||||
|
||||
missing = all.filter(function(elem) {return list.indexOf(elem) == -1});
|
||||
print(missing); // ==> DBAC
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
split:{1_'(&x=y)_ x:y,x}
|
||||
|
||||
g: ("ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB")
|
||||
g,:(" CDBA CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB")
|
||||
p: split[g;" "];
|
||||
|
||||
/ All permutations of "ABCD"
|
||||
perm:{:[1<x;,/(>:'(x,x)#1,x#0)[;0,'1+_f x-1];,!x]}
|
||||
p2:a@(perm(#a:"ABCD"));
|
||||
|
||||
/ Which permutations in p are there in p2?
|
||||
p2 _lin p
|
||||
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1
|
||||
|
||||
/ Invert the result
|
||||
~p2 _lin p
|
||||
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
|
||||
|
||||
/ It's the 20th permutation that is missing
|
||||
&~p2 _lin p
|
||||
,20
|
||||
|
||||
p2@&~p2 _lin p
|
||||
"DBAC"
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
table:{b@<b:(x@*:'a),'#:'a:=x}
|
||||
,/"ABCD"@&:'{5=(table p[;x])[;1]}'!4
|
||||
"DBAC"
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
function perm = findMissingPerms(list)
|
||||
|
||||
permsList = perms(list(1,:)); %Generate all permutations of the 4 letters
|
||||
perm = []; %This is the functions return value if the list is not missing a permutation
|
||||
|
||||
%Normally the rest of this would be vectorized, but because this is
|
||||
%done on a vector of strings, the vectorized functions will only access
|
||||
%one character at a time. So, in order for this to work we have to use
|
||||
%loops.
|
||||
for i = (1:size(permsList,1))
|
||||
|
||||
found = false;
|
||||
|
||||
for j = (1:size(list,1))
|
||||
if (permsList(i,:) == list(j,:))
|
||||
found = true;
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
if not(found)
|
||||
perm = permsList(i,:);
|
||||
return
|
||||
end
|
||||
|
||||
end %for
|
||||
end %fingMissingPerms
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
>> list = ['ABCD';
|
||||
'CABD';
|
||||
'ACDB';
|
||||
'DACB';
|
||||
'BCDA';
|
||||
'ACBD';
|
||||
'ADCB';
|
||||
'CDAB';
|
||||
'DABC';
|
||||
'BCAD';
|
||||
'CADB';
|
||||
'CDBA';
|
||||
'CBAD';
|
||||
'ABDC';
|
||||
'ADBC';
|
||||
'BDCA';
|
||||
'DCBA';
|
||||
'BACD';
|
||||
'BADC';
|
||||
'BDAC';
|
||||
'CBDA';
|
||||
'DBCA';
|
||||
'DCAB']
|
||||
|
||||
list =
|
||||
|
||||
ABCD
|
||||
CABD
|
||||
ACDB
|
||||
DACB
|
||||
BCDA
|
||||
ACBD
|
||||
ADCB
|
||||
CDAB
|
||||
DABC
|
||||
BCAD
|
||||
CADB
|
||||
CDBA
|
||||
CBAD
|
||||
ABDC
|
||||
ADBC
|
||||
BDCA
|
||||
DCBA
|
||||
BACD
|
||||
BADC
|
||||
BDAC
|
||||
CBDA
|
||||
DBCA
|
||||
DCAB
|
||||
|
||||
>> findMissingPerms(list)
|
||||
|
||||
ans =
|
||||
|
||||
DBAC
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
ProvidedSet = {"ABCD" , "CABD" , "ACDB" , "DACB" , "BCDA" , "ACBD",
|
||||
"ADCB" , "CDAB", "DABC", "BCAD" , "CADB", "CDBA" , "CBAD" , "ABDC",
|
||||
"ADBC" , "BDCA", "DCBA" , "BACD", "BADC", "BDAC" , "CBDA", "DBCA", "DCAB"}
|
||||
|
||||
Part[Complement[ Map[ StringJoin , Permutations[Characters[RandomChoice[ProvidedSet]]]], ProvidedSet], 1]
|
||||
|
||||
->"DBAC"
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
<?php
|
||||
$finalres = Array();
|
||||
function permut($arr,$result=array()){
|
||||
global $finalres;
|
||||
if(empty($arr)){
|
||||
$finalres[] = implode("",$result);
|
||||
}else{
|
||||
foreach($arr as $key => $val){
|
||||
$newArr = $arr;
|
||||
$newres = $result;
|
||||
$newres[] = $val;
|
||||
unset($newArr[$key]);
|
||||
permut($newArr,$newres);
|
||||
}
|
||||
}
|
||||
}
|
||||
$givenPerms = Array("ABCD","CABD","ACDB","DACB","BCDA","ACBD","ADCB","CDAB","DABC","BCAD","CADB","CDBA","CBAD","ABDC","ADBC","BDCA","DCBA","BACD","BADC","BDAC","CBDA","DBCA","DCAB");
|
||||
$given = Array("A","B","C","D");
|
||||
permut($given);
|
||||
print_r(array_diff($finalres,$givenPerms)); // Array ( [20] => DBAC )
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
sub check_perm {
|
||||
my %hash; @hash{@_} = ();
|
||||
for my $s (@_) { exists $hash{$_} or return $_
|
||||
for map substr($s,1) . substr($s,0,1), (1..length $s); }
|
||||
}
|
||||
|
||||
# Check and display
|
||||
@perms = qw(ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA
|
||||
CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB);
|
||||
print check_perm(@perms), "\n";
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
(setq *PermList
|
||||
(mapcar chop
|
||||
(quote
|
||||
"ABCD" "CABD" "ACDB" "DACB" "BCDA" "ACBD" "ADCB" "CDAB"
|
||||
"DABC" "BCAD" "CADB" "CDBA" "CBAD" "ABDC" "ADBC" "BDCA"
|
||||
"DCBA" "BACD" "BADC" "BDAC" "CBDA" "DBCA" "DCAB" ) ) )
|
||||
|
||||
(let (Lst (chop "ABCD") L Lst)
|
||||
(recur (L) # Permute
|
||||
(if (cdr L)
|
||||
(do (length L)
|
||||
(recurse (cdr L))
|
||||
(rot L) )
|
||||
(unless (member Lst *PermList) # Check
|
||||
(prinl Lst) ) ) ) )
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
from itertools import permutations
|
||||
|
||||
given = '''ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA
|
||||
CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB'''.split()
|
||||
|
||||
allPerms = [''.join(x) for x in permutations(given[0])]
|
||||
|
||||
missing = list(set(allPerms) - set(given)) # ['DBAC']
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
def missing_permutation(arr):
|
||||
"Find the missing permutation in an array of N! - 1 permutations."
|
||||
|
||||
# We won't validate every precondition, but we do have some basic
|
||||
# guards.
|
||||
if len(arr) == 0: raise Exception("Need more data")
|
||||
if len(arr) == 1:
|
||||
return [arr[0][1] + arr[0][0]]
|
||||
|
||||
# Now we know that for each position in the string, elements should appear
|
||||
# an even number of times (N-1 >= 2). We can use a set to detect the element appearing
|
||||
# an odd number of times. Detect odd occurrences by toggling admission/expulsion
|
||||
# to and from the set for each value encountered. At the end of each pass one element
|
||||
# will remain in the set.
|
||||
missing_permutation = ''
|
||||
for pos in range(len(arr[0])):
|
||||
s = set()
|
||||
for permutation in arr:
|
||||
c = permutation[pos]
|
||||
if c in s:
|
||||
s.remove(c)
|
||||
else:
|
||||
s.add(c)
|
||||
missing_permutation += list(s)[0]
|
||||
return missing_permutation
|
||||
|
||||
given = '''ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA
|
||||
CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB'''.split()
|
||||
|
||||
print missing_permutation(given)
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
>>> from collections import Counter
|
||||
>>> given = '''ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA
|
||||
CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB'''.split()
|
||||
>>> ''.join(Counter(x).most_common()[-1][0] for x in zip(*given))
|
||||
'DBAC'
|
||||
>>>
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
>>> from pprint import pprint as pp
|
||||
>>> pp(list(zip(*given)), width=120)
|
||||
[('A', 'C', 'A', 'D', 'B', 'A', 'A', 'C', 'D', 'B', 'C', 'C', 'C', 'A', 'A', 'B', 'D', 'B', 'B', 'B', 'C', 'D', 'D'),
|
||||
('B', 'A', 'C', 'A', 'C', 'C', 'D', 'D', 'A', 'C', 'A', 'D', 'B', 'B', 'D', 'D', 'C', 'A', 'A', 'D', 'B', 'B', 'C'),
|
||||
('C', 'B', 'D', 'C', 'D', 'B', 'C', 'A', 'B', 'A', 'D', 'B', 'A', 'D', 'B', 'C', 'B', 'C', 'D', 'A', 'D', 'C', 'A'),
|
||||
('D', 'D', 'B', 'B', 'A', 'D', 'B', 'B', 'C', 'D', 'B', 'A', 'D', 'C', 'C', 'A', 'A', 'D', 'C', 'C', 'A', 'A', 'B')]
|
||||
>>> pp([Counter(x).most_common() for x in zip(*given)])
|
||||
[[('C', 6), ('B', 6), ('A', 6), ('D', 5)],
|
||||
[('D', 6), ('C', 6), ('A', 6), ('B', 5)],
|
||||
[('D', 6), ('C', 6), ('B', 6), ('A', 5)],
|
||||
[('D', 6), ('B', 6), ('A', 6), ('C', 5)]]
|
||||
>>> pp([Counter(x).most_common()[-1] for x in zip(*given)])
|
||||
[('D', 5), ('B', 5), ('A', 5), ('C', 5)]
|
||||
>>> pp([Counter(x).most_common()[-1][0] for x in zip(*given)])
|
||||
['D', 'B', 'A', 'C']
|
||||
>>> ''.join([Counter(x).most_common()[-1][0] for x in zip(*given)])
|
||||
'DBAC'
|
||||
>>>
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
library(combinat)
|
||||
|
||||
permute.me <- c("A", "B", "C", "D")
|
||||
perms <- permn(permute.me) # list of all permutations
|
||||
perms2 <- matrix(unlist(perms), ncol=length(permute.me), byrow=T) # matrix of all permutations
|
||||
perms3 <- apply(perms2, 1, paste, collapse="") # vector of all permutations
|
||||
|
||||
incomplete <- c("ABCD", "CABD", "ACDB", "DACB", "BCDA", "ACBD", "ADCB", "CDAB",
|
||||
"DABC", "BCAD", "CADB", "CDBA", "CBAD", "ABDC", "ADBC", "BDCA",
|
||||
"DCBA", "BACD", "BADC", "BDAC", "CBDA", "DBCA", "DCAB")
|
||||
|
||||
setdiff(perms3, incomplete)
|
||||
|
|
@ -0,0 +1 @@
|
|||
[1] "DBAC"
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
/*REXX program finds a missing permuation from an internal list. */
|
||||
|
||||
list='ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA',
|
||||
'CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB'
|
||||
|
||||
@.=; @abcU='ABCDEFGUIJKLMNOPQRSTUVWXYZ'
|
||||
things=4
|
||||
bunch=4
|
||||
do j=1 for things /*build list of permutation obj. */
|
||||
$.j=substr(@abcu,j,1)
|
||||
end /*j*/
|
||||
call permset 1
|
||||
exit
|
||||
/*─────────────────────────────────────PERMSET subroutine───────────────*/
|
||||
permset:procedure expose $. @. bunch list things; parse arg ?
|
||||
if ?>bunch then do; _=@.1; do m=2 to bunch
|
||||
_=_||@.m
|
||||
end /*m*/
|
||||
if wordpos(_,list)==0 then say _ ' is missing from the list.'
|
||||
end
|
||||
else do x=1 for things /*construction a new permuation. */
|
||||
do k=1 for ?-1; if @.k==$.x then iterate x; end /*k*/
|
||||
@.?=$.x
|
||||
call permset ?+1
|
||||
end /*x*/
|
||||
return
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
given = %w{
|
||||
ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA
|
||||
CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB
|
||||
}
|
||||
|
||||
all = given[0].split(//).permutation.collect {|perm| perm.join('')}
|
||||
|
||||
missing = all - given # ["DBAC"]
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
def fat(n: Int) = (2 to n).foldLeft(1)(_*_)
|
||||
def perm[A](x: Int, a: Seq[A]): Seq[A] = if (x == 0) a else {
|
||||
val n = a.size
|
||||
val fatN1 = fat(n - 1)
|
||||
val fatN = fatN1 * n
|
||||
val p = x / fatN1 % fatN
|
||||
val (before, Seq(el, after @ _*)) = a splitAt p
|
||||
el +: perm(x % fatN1, before ++ after)
|
||||
}
|
||||
def findMissingPerm(start: String, perms: Array[String]): String = {
|
||||
for {
|
||||
i <- 0 until fat(start.size)
|
||||
p = perm(i, start).mkString
|
||||
} if (!perms.contains(p)) return p
|
||||
""
|
||||
}
|
||||
val perms = """ABCD
|
||||
CABD
|
||||
ACDB
|
||||
DACB
|
||||
BCDA
|
||||
ACBD
|
||||
ADCB
|
||||
CDAB
|
||||
DABC
|
||||
BCAD
|
||||
CADB
|
||||
CDBA
|
||||
CBAD
|
||||
ABDC
|
||||
ADBC
|
||||
BDCA
|
||||
DCBA
|
||||
BACD
|
||||
BADC
|
||||
BDAC
|
||||
CBDA
|
||||
DBCA
|
||||
DCAB""".stripMargin.split("\n")
|
||||
println(findMissingPerm(perms(0), perms))
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
println("missing perms: "+("ABCD".permutations.toSet
|
||||
--"ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB".stripMargin.split(" ").toSet))
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
package require struct::list
|
||||
package require struct::set
|
||||
|
||||
# Make complete list of permutations of a string of characters
|
||||
proc allCharPerms s {
|
||||
set perms {}
|
||||
set p [struct::list firstperm [split $s {}]]
|
||||
while {$p ne ""} {
|
||||
lappend perms [join $p {}]
|
||||
set p [struct::list nextperm $p]
|
||||
}
|
||||
return $perms
|
||||
}
|
||||
|
||||
# The set of provided permutations (wrapped for convenience)
|
||||
set have {
|
||||
ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA CBAD ABDC
|
||||
ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB
|
||||
}
|
||||
# Get the real list of permutations...
|
||||
set all [allCharPerms [lindex $have 0]]
|
||||
# Find the missing one(s)!
|
||||
set missing [struct::set difference $all $have]
|
||||
puts "missing permutation(s): $missing"
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
package require struct::list
|
||||
package require struct::set
|
||||
|
||||
proc foreachPermutation {varName listToPermute body} {
|
||||
upvar 1 $varName v
|
||||
set p [struct::list firstperm $listToPermute]
|
||||
for {} {$p ne ""} {set p [struct::list nextperm $p]} {
|
||||
set v $p; uplevel 1 $body
|
||||
}
|
||||
}
|
||||
|
||||
proc findMissingCharPermutations {set} {
|
||||
set all {}
|
||||
foreachPermutation charPerm [split [lindex $set 0] {}] {
|
||||
lappend all [join $charPerm {}]
|
||||
}
|
||||
return [struct::set difference $all $set]
|
||||
}
|
||||
|
||||
set have {
|
||||
ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA CBAD ABDC
|
||||
ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB
|
||||
}
|
||||
set missing [findMissingCharPermutations $have]
|
||||
Loading…
Add table
Add a link
Reference in a new issue