sciencetalk

Code: Selecteer alles

import java.util.*;

public class PermutatieVb {

public static void main(String args[]) throws Exception {

Scanner input = new Scanner(System.in);

System.out.print("Geef string: ");

String chars = input.next();

toonPermutaties("", chars);

}

public static void toonPermutaties(String st, String chars) {

if (chars.length() <= 1)

System.out.println(st + chars);

else

for (int i = 0; i < chars.length(); i++) {

try {

String newString = chars.substring(0, i) + chars.substring(i + 1);

toonPermutaties(st + chars.charAt(i), newString);

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

Code: Selecteer alles

def anagrammen(woord):

a=['']

for x in range(len(woord)):

temp=[]

for anagram in a:

for letter in [i for i in woord if anagram.count(i)<woord.count(i)]:

if not (anagram+letter) in temp:

temp.append(anagram+letter)

a=temp[:]

return a

Code: Selecteer alles

function Anagrammen( $s )

{

 $n = strlen($s);

 $u = range(0,$n-1);

 for ($w=array();;$r='')

 {

  for ($i=0; $i<$n; $i++) $r .= $s[$u[$i]];

  if (!in_array($r,$w)) $w[] = $r;

  for ($i-=($k=1); $i<$n; $i+=1-$k)

  {

   if ($k && ++$u[$i]==$n) { if (!$i) return $w; $u[$i--] = 0; continue; }

   for ($j=$k=0; $j<$i; $j++) if ($u[$i]==$u[$j]) { $k = 1; break; }

  }

 }

}

Code: Selecteer alles

import Data.List

-- using 'permutations'

solution1 = nub $ permutations "test"

-- using own permutation function

solution2 = nub $ perms "test"

where

perms (x:[]) = [[x]]

perms xs = concat [map (x:) (perms (xs \\ [x])) | x <- xs]

-- using own permutation function with nub in a better place

solution3 = perms "test"

where

perms (x:[]) = [[x]]

perms xs = concat [map (x:) (perms (xs \\ [x])) | x <- nub xs]

Code: Selecteer alles

-- not really different from solution3: avoids [x] construction.

solution4 = perms "test"

    where

        perms [] = [[]]

        perms xs = concat [map (x:) (perms (delete x xs)) | x <- nub xs]



solution5 = perms "test"

	where

		perms xs = traceThrough (createGraph xs) (sort xs)



createGraph xs = createGraph' Map.empty (sort xs) 

createGraph' m [] = m

createGraph' m xs = case (Map.lookup xs m) of

							 Nothing -> foldl createGraph' (Map.insert xs links m) (map snd links)

							 Just x  -> m

	where

		links = [(x, delete x xs)| x <- nub xs]



traceThrough _ "" = [""]

traceThrough m xs = concat [map (a:) (traceThrough m b) | (a,b) <- links]

	where

		Just links = Map.lookup xs m