all tasks

Task/Symmetric-difference/0DESCRIPTION

@@ -0,0 +1,27 @@
+Given two [[set]]s ''A'' and ''B'', where ''A'' contains:
+
+* John
+* Bob
+* Mary
+* Serena
+
+and ''B'' contains:
+
+* Jim
+* Mary
+* John
+* Bob
+
+compute
+
+:<math>(A \setminus B) \cup (B \setminus A).</math>
+
+That is, enumerate the items that are in ''A'' or ''B'' but not both. This set is called the [[wp:Symmetric difference|symmetric difference]] of ''A'' and ''B''.
+
+In other words: <math>(A \cup B) \setminus (A \cap B)</math> (the set of items that are in at least one of ''A'' or ''B'' minus the set of items that are in both ''A'' and ''B'').
+
+Optionally, give the individual differences (<math>A \setminus B</math> and <math>B \setminus A</math>) as well.
+
+;Notes
+# If your code uses lists of items to represent sets then ensure duplicate items in lists are correctly handled. For example two lists representing sets of <code>a = ["John", "Serena", "Bob", "Mary", "Serena"]</code> and <code>b = ["Jim", "Mary", "John", "Jim", "Bob"]</code> should produce the result of just two strings: <code>["Serena", "Jim"]</code>, in any order.
+# In the mathematical notation above <code>A \ B</code> gives the set of items in A that are not in B; <code>A ∪ B</code> gives the set of items in both A and B, (their ''union''); and <code>A ∩ B</code> gives the set of items that are in both A and B (their ''intersection'').

Task/Symmetric-difference/1META.yaml

@@ -0,0 +1,2 @@
+---
+note: Discrete math

Task/Symmetric-difference/Ada/symmetric-difference.ada

@@ -0,0 +1,27 @@
+with Ada.Text_IO;  use Ada.Text_IO;
+
+procedure Test_XOR is
+   type Person is (John, Bob, Mary, Serena, Jim);
+   type Group is array (Person) of Boolean;
+   procedure Put (Set : Group) is
+      First : Boolean := True;
+   begin
+      for I in Set'Range loop
+         if Set (I) then
+            if First then
+               First := False;
+            else
+               Put (',');
+            end if;
+            Put (Person'Image (I));
+         end if;
+      end loop;
+   end Put;
+
+   A : Group := (John | Bob | Mary | Serena => True, others => False);
+   B : Group := (Jim | Mary | John | Bob    => True, others => False);
+begin
+   Put ("A xor B = "); Put (A xor B);     New_Line;
+   Put ("A - B   = "); Put (A and not B); New_Line;
+   Put ("B - A   = "); Put (B and not A); New_Line;
+end Test_XOR;

Task/Symmetric-difference/AutoHotkey/symmetric-difference.ahk

@@ -0,0 +1,23 @@
+setA = John, Bob, Mary, Serena
+setB = Jim, Mary, John, Bob
+MsgBox,, Singles, % SymmetricDifference(setA, setB)
+
+setA = John, Serena, Bob, Mary, Serena
+setB = Jim, Mary, John, Jim, Bob
+MsgBox,, Duplicates, % SymmetricDifference(setA, setB)
+
+;---------------------------------------------------------------------------
+SymmetricDifference(A, B) { ; returns the symmetric difference of A and B
+;---------------------------------------------------------------------------
+    StringSplit, A_, A, `,, %A_Space%
+    Loop, %A_0%
+        If Not InStr(B, A_%A_Index%)
+        And Not InStr(Result, A_%A_Index%)
+            Result .= A_%A_Index% ", "
+    StringSplit, B_, B, `,, %A_Space%
+    Loop, %B_0%
+        If Not InStr(A, B_%A_Index%)
+        And Not InStr(Result, B_%A_Index%)
+            Result .= B_%A_Index% ", "
+    Return, SubStr(Result, 1, -2)
+}

Task/Symmetric-difference/BBC-BASIC/symmetric-difference.bbc

@@ -0,0 +1,23 @@
+      DIM list$(4)
+      list$() = "Bob", "Jim", "John", "Mary", "Serena"
+
+      setA% = %11101
+      PRINT "Set A: " FNlistset(list$(), setA%)
+      setB% = %01111
+      PRINT "Set B: " FNlistset(list$(), setB%)
+
+      REM Compute symmetric difference:
+      setC% = setA% EOR setB%
+      PRINT '"Symmetric difference: " FNlistset(list$(), setC%)
+
+      REM Optional:
+      PRINT "Set A \ Set B: " FNlistset(list$(), setA% AND NOT setB%)
+      PRINT "Set B \ Set A: " FNlistset(list$(), setB% AND NOT setA%)
+      END
+
+      DEF FNlistset(list$(), set%)
+      LOCAL i%, o$
+      FOR i% = 0 TO 31
+        IF set% AND 1 << i% o$ += list$(i%) + ", "
+      NEXT
+      = LEFT$(LEFT$(o$))

Task/Symmetric-difference/Bracmat/symmetric-difference-1.bracmat

@@ -0,0 +1,16 @@
+(SymmetricDifference=
+  A B x symdiff
+.   !arg:(?A.?B)
+  & :?symdiff
+  & (   !A !B
+      :   ?
+          ( %@?x
+          & ( !A:? !x ?&!B:? !x ?
+            | !symdiff:? !x ?
+            | !symdiff !x:?symdiff
+            )
+          & ~
+          )
+          ?
+    | !symdiff
+    ));

Task/Symmetric-difference/Bracmat/symmetric-difference-2.bracmat

@@ -0,0 +1 @@
+SymmetricDifference$(john serena bob mary serena.jim mary john jim bob)

Task/Symmetric-difference/Bracmat/symmetric-difference-3.bracmat

@@ -0,0 +1 @@
+serena jim

Task/Symmetric-difference/C++/symmetric-difference.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <set>
+#include <algorithm>
+#include <iterator>
+#include <string>
+
+using namespace std;
+
+int main( ) {
+   string setA[] = { "John", "Bob" , "Mary", "Serena" };
+   string setB[] = { "Jim" , "Mary", "John", "Bob"  };
+   set<string>
+       firstSet( setA , setA + 4 ),
+       secondSet( setB , setB + 4 ),
+       symdiff;
+
+   set_symmetric_difference( firstSet.begin(), firstSet.end(),
+                             secondSet.begin(), secondSet.end(),
+                             inserter( symdiff, symdiff.end() ) );
+
+   copy( symdiff.begin(), symdiff.end(), ostream_iterator<string>( cout , " " ) );
+   cout << endl;
+   return 0;
+}

Task/Symmetric-difference/C/symmetric-difference-1.c

@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <string.h>
+
+const char *A[] = { "John", "Serena", "Bob", "Mary", "Serena" };
+const char *B[] = { "Jim", "Mary", "John", "Jim", "Bob" };
+
+#define LEN(x) sizeof(x)/sizeof(x[0])
+
+/* null duplicate items */
+void uniq(const char *x[], int len)
+{
+	int i, j;
+	for (i = 0; i < len; i++)
+		for (j = i + 1; j < len; j++)
+			if (x[j] && x[i] && !strcmp(x[i], x[j])) x[j] = 0;
+}
+
+int in_set(const char *const x[], int len, const char *match)
+{
+	int i;
+	for (i = 0; i < len; i++)
+		if (x[i] && !strcmp(x[i], match))
+			return 1;
+	return 0;
+}
+
+/* x - y */
+void show_diff(const char *const x[], int lenx, const char *const y[], int leny)
+{
+	int i;
+	for (i = 0; i < lenx; i++)
+		if (x[i] && !in_set(y, leny, x[i]))
+			printf("  %s\n", x[i]);
+}
+
+/* X ^ Y */
+void show_sym_diff(const char *const x[], int lenx, const char *const y[], int leny)
+{
+	show_diff(x, lenx, y, leny);
+	show_diff(y, leny, x, lenx);
+}
+
+int main()
+{
+	uniq(A, LEN(A));
+	uniq(B, LEN(B));
+	printf("A \\ B:\n"); show_diff(A, LEN(A), B, LEN(B));
+	printf("\nB \\ A:\n"); show_diff(B, LEN(B), A, LEN(A));
+	printf("\nA ^ B:\n");  show_sym_diff(A, LEN(A), B, LEN(B));
+
+	return 0;
+}

Task/Symmetric-difference/C/symmetric-difference-2.c

@@ -0,0 +1,135 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+const char *mary="Mary";
+const char *bob="Bob";
+const char *jim="Jim";
+const char *john="John";
+const char *serena="Serena";
+
+const char *setA[] = {john,bob,mary,serena};
+const char *setB[] = {jim,mary,john,bob};
+
+#define XSET(j)  j, (sizeof(j)/sizeof(*j))
+#define TALLOC(n,typ) malloc(n*sizeof(typ))
+
+typedef enum {
+    esdDIFFERENCE,
+    esdSYMMETRIC } EsdFunction;
+/** * * * * * * * * * * * * * * * * * * * *
+ * return value is difference or symmetric difference set
+ *    its size is returned in sym_size
+ *    f determinse whether it is a symmetric difference, or normal difference
+ * * * * * * * * * * * * * * * * * * * * **/
+const char ** symmdiff( int *sym_size, EsdFunction f, const char *setA[], int setAsize, const char *setB[], int setBsize)
+{
+    int union_size;
+    int max_union_size;
+    int diff_size;
+    const char **union_set;
+    const char **diff_set;
+    int *union_xor;
+    int ix, ixu;
+
+    max_union_size = setAsize + setBsize;
+    union_set = TALLOC(max_union_size, const char *);
+    union_xor = TALLOC(max_union_size, int);
+
+    /* I'm assuming here that setA has no duplicates,
+     * i.e. is a set in mathematical sense */
+    for (ix=0; ix<setAsize; ix++) {
+        union_set[ix] = setA[ix];
+        union_xor[ix] = 1;
+    }
+    diff_size = union_size = setAsize;
+    for (ix=0; ix<setBsize; ix++) {
+        for (ixu=0; ixu<union_size; ixu++) {
+            if (union_set[ixu] == setB[ix]) break;
+        }
+        if (ixu < union_size) {	/* already in union */
+            union_xor[ixu] = 1-union_xor[ixu];
+            diff_size--;
+        }
+        else {		/* not already in union -add */
+            if (f == esdSYMMETRIC) {
+                union_set[ixu] = setB[ix];
+                union_xor[ixu] = 1;
+                union_size++;
+                diff_size++;
+            }
+        }
+    }
+    /* Put results in symdiff set */
+    diff_set = TALLOC(diff_size, const char *);
+    ix = 0;
+    for (ixu=0; ixu<union_size; ixu++) {
+        if (union_xor[ixu]) {
+            if (ix == diff_size) {
+                printf("Short of space in diff_set\n");
+                exit(1);
+            }
+            diff_set[ix] = union_set[ixu];
+            ix++;
+        }
+    }
+    *sym_size = diff_size;
+    free(union_xor);
+    free(union_set);
+    return diff_set;
+}
+
+/* isSet tests that elements of list are unique, that is, that the list is a
+ * mathematical set.  The uniqueness test implemented here is strcmp. */
+int isSet(const char *list[], int lsize)
+{
+    int i, j;
+    const char *e;
+    if (lsize == 0) {
+        return 1;
+    }
+    for (i = lsize-1; i>0; i--) {
+        e = list[i];
+        for (j = i-1; j>=0; j--) {
+            if (strcmp(list[j], e) == 0) {
+                return 0;
+            }
+        }
+    }
+    return 1;
+}
+
+void printSet (const char *set[], int ssize)
+{
+    int ix;
+    printf(" = {");
+    for (ix=0;ix<ssize; ix++) {
+        printf( "%s ", set[ix]);
+    }
+    printf("}\n");
+}
+
+int main()
+{
+    const char **symset;
+    int sysize;
+
+    /* Validate precondition stated by task, that inputs are sets. */
+    assert(isSet(XSET(setA)));
+    assert(isSet(XSET(setB)));
+
+    printf ("A symmdiff B");
+    symset = symmdiff( &sysize, esdSYMMETRIC, XSET(setA), XSET(setB));
+    printSet(symset, sysize);
+    free(symset);
+    printf ("A - B");
+    symset = symmdiff( &sysize, esdDIFFERENCE, XSET(setA), XSET(setB));
+    printSet(symset, sysize);
+    printf ("B - A");
+    symset = symmdiff( &sysize, esdDIFFERENCE, XSET(setB), XSET(setA));
+    printSet(symset, sysize);
+    free(symset);
+
+    return 0;
+}

Task/Symmetric-difference/Clojure/symmetric-difference.clj

@@ -0,0 +1,6 @@
+(use '[clojure.set])
+
+(defn symmetric-difference [s1 s2]
+  (union (difference s1 s2) (difference s2 s1)))
+
+(symmetric-difference #{:john :bob :mary :serena} #{:jim :mary :john :bob})

Task/Symmetric-difference/Common-Lisp/symmetric-difference.lisp

@@ -0,0 +1,3 @@
+(set-exclusive-or
+  (remove-duplicates '(John Serena Bob Mary Serena))
+  (remove-duplicates '(Jim Mary John Jim Bob)))

Task/Symmetric-difference/D/symmetric-difference.d

@@ -0,0 +1,26 @@
+import std.stdio, std.algorithm, std.array;
+
+struct Set(T) {
+    immutable T[] items;
+
+    Set opSub(in Set other) const /*pure nothrow*/ {
+        return Set(array(filter!(a=> !canFind(other.items,a))(items)));
+    }
+
+    Set opAdd(in Set other) const /*pure nothrow*/ {
+        return Set(this.items ~ (other - this).items);
+    }
+}
+
+Set!T symmetricDifference(T)(in Set!T left, in Set!T right) {
+    return (left - right) + (right - left);
+}
+
+void main() {
+    immutable A = Set!string(["John", "Bob", "Mary", "Serena"]);
+    immutable B = Set!string(["Jim", "Mary", "John", "Bob"]);
+
+    writeln("        A\\B: ", (A - B).items);
+    writeln("        B\\A: ", (B - A).items);
+    writeln("A symdiff B: ", symmetricDifference(A, B).items);
+}

Task/Symmetric-difference/E/symmetric-difference.e

@@ -0,0 +1,5 @@
+? def symmDiff(a, b) { return (a &! b) | (b &! a) }
+# value: <symmDiff>
+
+? symmDiff(["John", "Bob", "Mary", "Serena"].asSet(), ["Jim", "Mary", "John", "Bob"].asSet())
+# value: ["Jim", "Serena"].asSet()

Task/Symmetric-difference/Eiffel/symmetric-difference.e

@@ -0,0 +1,45 @@
+note
+	description: "Summary description for {SYMETRIC_DIFFERENCE_EXAMPLE}."
+	URI: "http://rosettacode.org/wiki/Symmetric_difference"
+
+class
+	SYMETRIC_DIFFERENCE_EXAMPLE
+
+create
+	make
+
+feature {NONE} -- Initialization
+
+	make
+		local
+			a,a1,b,b1: ARRAYED_SET [STRING]
+		do
+			create a.make (4)
+			create b.make (4)
+			a.compare_objects
+			b.compare_objects
+			a.put ("John")
+			a.put ("Bob")
+			a.put ("Mary")
+			a.put ("Serena")
+
+			create a1.make (4)
+			a1.copy (a)
+
+			b.put ("Jim")
+			b.put ("Mary")
+			b.put ("John")
+			b.put ("Bob")
+
+			create b1.make (4)
+			b1.copy (b)
+
+		    a1.subtract (b1)
+		    b.subtract (a)
+		    a1.merge (b)
+		    across a1 as c loop
+		    	print (" " + c.item)
+		    end
+		end
+
+end

Task/Symmetric-difference/Factor/symmetric-difference.factor

@@ -0,0 +1,4 @@
+: symmetric-diff ( a b -- c )
+    [ diff ] [ swap diff ] 2bi append ;
+
+{ "John" "Bob" "Mary" "Serena" } { "Jim" "Mary" "John" "Bob" } symmetric-diff .

Task/Symmetric-difference/Forth/symmetric-difference.fth

@@ -0,0 +1,23 @@
+: elm	( n -- ; one cell per set )
+	[ cell 8 * 1- ] literal umin CREATE 1 swap lshift ,
+DOES> 	( -- 2^n ) @ ;
+
+: universe	( u "name" -- )
+	dup 0 DO I elm latest swap LOOP
+	CREATE dup , 0 DO , LOOP
+	DOES>  ( n a -- )  dup @ tuck cells +
+		swap 0
+		DO	( n a' )
+			over I rshift 1 AND
+			IF dup @ name>string space type THEN
+			1 cells -
+		LOOP	2drop ;
+
+5 universe john bob mary serena jim	persons
+john bob mary serena or or or
+jim mary john bob    or or or
+
+2dup xor           persons
+2dup -1 xor and cr persons
+swap -1 xor and cr persons
+cr bye

Task/Symmetric-difference/Fortran/symmetric-difference.f

@@ -0,0 +1,22 @@
+program Symmetric_difference
+implicit none
+
+  character(6) :: a(4) = (/ "John  ", "Bob   ", "Mary  ", "Serena" /)
+  character(6) :: b(4) = (/ "Jim   ", "Mary  ", "John  ", "Bob   " /)
+  integer :: i, j
+
+outer1: do i = 1, size(a)
+          do j = 1, i-1
+            if(a(i) == a(j)) cycle outer1   ! Do not check duplicate items
+          end do
+          if(.not. any(b == a(i))) write(*,*) a(i)
+        end do outer1
+
+outer2: do i = 1, size(b)
+          do j = 1, i-1
+            if(b(i) == b(j)) cycle outer2   ! Do not check duplicate items
+          end do
+          if(.not. any(a == b(i))) write(*,*) b(i)
+        end do outer2
+
+end program

Task/Symmetric-difference/GAP/symmetric-difference.gap

@@ -0,0 +1,8 @@
+SymmetricDifference := function(a, b)
+  return Union(Difference(a, b), Difference(b, a));
+end;
+
+a := ["John", "Serena", "Bob", "Mary", "Serena"];
+b := ["Jim", "Mary", "John", "Jim", "Bob"];
+SymmetricDifference(a,b);
+[ "Jim", "Serena" ]

Task/Symmetric-difference/Go/symmetric-difference-1.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+var a = map[string]bool{"John": true, "Bob": true, "Mary": true, "Serena": true}
+var b = map[string]bool{"Jim": true, "Mary": true, "John": true, "Bob": true}
+
+func main() {
+    sd := make(map[string]bool)
+    for e := range a {
+        if !b[e] {
+            sd[e] = true
+        }
+    }
+    for e := range b {
+        if !a[e] {
+            sd[e] = true
+        }
+    }
+    fmt.Println(sd)
+}

Task/Symmetric-difference/Go/symmetric-difference-2.go

@@ -0,0 +1,6 @@
+func main() {
+    for e := range b {
+        delete(a, e)
+    }
+    fmt.Println(a)
+}

Task/Symmetric-difference/Groovy/symmetric-difference-1.groovy

@@ -0,0 +1,5 @@
+def symDiff = { Set s1, Set s2 ->
+    assert s1 != null
+    assert s2 != null
+    (s1 + s2) - (s1.intersect(s2))
+}

Task/Symmetric-difference/Groovy/symmetric-difference-2.groovy

@@ -0,0 +1,93 @@
+Set a = ['John', 'Serena', 'Bob', 'Mary', 'Serena']
+Set b = ['Jim', 'Mary', 'John', 'Jim', 'Bob']
+
+assert a.size() == 4
+assert a == (['Bob', 'John', 'Mary', 'Serena'] as Set)
+assert b.size() == 4
+assert b == (['Bob', 'Jim', 'John', 'Mary'] as Set)
+
+def aa = symDiff(a, a)
+def ab = symDiff(a, b)
+def ba = symDiff(b, a)
+def bb = symDiff(b, b)
+
+assert aa.empty
+assert bb.empty
+assert ab == ba
+assert ab == (['Jim', 'Serena'] as Set)
+assert ab == (['Serena', 'Jim'] as Set)
+
+println """
+a: ${a}
+b: ${b}
+
+Symmetric Differences
+=====================
+a <> a: ${aa}
+a <> b: ${ab}
+b <> a: ${ba}
+b <> b: ${bb}
+
+
+"""
+
+Set apostles = ['Matthew', 'Mark', 'Luke', 'John', 'Peter', 'Paul', 'Silas']
+Set beatles = ['John', 'Paul', 'George', 'Ringo', 'Peter', 'Stuart']
+Set csny = ['Crosby', 'Stills', 'Nash', 'Young']
+Set ppm = ['Peter', 'Paul', 'Mary']
+
+def AA = symDiff(apostles, apostles)
+def AB = symDiff(apostles, beatles)
+def AC = symDiff(apostles, csny)
+def AP = symDiff(apostles, ppm)
+
+def BA = symDiff(beatles, apostles)
+def BB = symDiff(beatles, beatles)
+def BC = symDiff(beatles, csny)
+def BP = symDiff(beatles, ppm)
+
+def CA = symDiff(csny, apostles)
+def CB = symDiff(csny, beatles)
+def CC = symDiff(csny, csny)
+def CP = symDiff(csny, ppm)
+
+def PA = symDiff(ppm, apostles)
+def PB = symDiff(ppm, beatles)
+def PC = symDiff(ppm, csny)
+def PP = symDiff(ppm, ppm)
+
+assert AB == BA
+assert AC == CA
+assert AP == PA
+assert BC == CB
+assert BP == PB
+assert CP == PC
+
+println """
+apostles: ${apostles}
+ beatles: ${beatles}
+    csny: ${csny}
+     ppm: ${ppm}
+
+Symmetric Differences
+=====================
+apostles <> apostles: ${AA}
+apostles <> beatles:  ${AB}
+apostles <> csny:     ${AC}
+apostles <> ppm:      ${AP}
+
+beatles <> apostles:  ${BA}
+beatles <> beatles:   ${BB}
+beatles <> csny:      ${BC}
+beatles <> ppm:       ${BP}
+
+csny <> apostles:     ${CA}
+csny <> beatles:      ${CB}
+csny <> csny:         ${CC}
+csny <> ppm:          ${CP}
+
+ppm <> apostles:      ${PA}
+ppm <> beatles:       ${PB}
+ppm <> csny:          ${PC}
+ppm <> ppm:           ${PP}
+"""

Task/Symmetric-difference/Haskell/symmetric-difference-1.hs

@@ -0,0 +1,8 @@
+import Data.Set
+
+a = fromList ["John", "Bob",  "Mary", "Serena"]
+b = fromList ["Jim",  "Mary", "John", "Bob"]
+
+(-|-) :: Ord a => Set a -> Set a -> Set a
+(-|-) x y = (x \\ y) `union` (y \\ x)
+  -- Equivalently: (x `union` y) \\ (x `intersect` y)

Task/Symmetric-difference/Haskell/symmetric-difference-2.hs

@@ -0,0 +1,2 @@
+*Main> a -|- b
+fromList ["Jim","Serena"]

Task/Symmetric-difference/Haskell/symmetric-difference-3.hs

@@ -0,0 +1,5 @@
+*Main> a \\ b
+fromList ["Serena"]
+
+*Main> b \\ a
+fromList ["Jim"]

Task/Symmetric-difference/HicEst/symmetric-difference.hicest

@@ -0,0 +1,19 @@
+CALL SymmDiff("John,Serena,Bob,Mary,Serena,", "Jim,Mary,John,Jim,Bob,")
+CALL SymmDiff("John,Bob,Mary,Serena,", "Jim,Mary,John,Bob,")
+
+SUBROUTINE SymmDiff(set1, set2)
+  CHARACTER set1, set2, answer*50
+  answer = " "
+  CALL setA_setB( set1, set2, answer )
+  CALL setA_setB( set2, set1, answer )
+  WRITE(Messagebox,Name) answer          ! answer = "Serena,Jim," in both cases
+END
+
+SUBROUTINE setA_setB( set1, set2, differences )
+  CHARACTER set1, set2, differences, a*100
+  a = set1
+  EDIT(Text=a, $inLeXicon=set2)     ! eg   a <= $John,Serena,$Bob,$Mary,Serena,
+  EDIT(Text=a, Right="$", Mark1, Right=",", Mark2, Delete, DO) ! Serena,Serena,
+  EDIT(Text=a, Option=1, SortDelDbls=a) ! Option=1: keep case;          Serena,
+  differences = TRIM( differences ) // a
+END

Task/Symmetric-difference/Icon/symmetric-difference.icon

@@ -0,0 +1,19 @@
+procedure main()
+
+a := set(["John", "Serena", "Bob", "Mary", "Serena"])
+b := set(["Jim", "Mary", "John", "Jim", "Bob"])
+
+showset("a",a)
+showset("b",b)
+showset("(a\\b) \xef (b\\a)",(a -- b) ++ (b -- a))
+showset("(a\\b)",a -- b)
+showset("(b\\a)",b -- a)
+end
+
+
+procedure showset(n,x)
+writes(n," = { ")
+every writes(!x," ")
+write("}")
+return
+end

Task/Symmetric-difference/J/symmetric-difference-1.j

@@ -0,0 +1,11 @@
+   A=: ~.;:'John Serena Bob Mary Serena'
+   B=: ~. ;:'Jim Mary John Jim Bob'
+
+   (A-.B) , (B-.A)   NB. Symmetric Difference
+┌──────┬───┐
+│Serena│Jim│
+└──────┴───┘
+   A (-. , -.~) B    NB. Tacit equivalent
+┌──────┬───┐
+│Serena│Jim│
+└──────┴───┘

Task/Symmetric-difference/J/symmetric-difference-2.j

@@ -0,0 +1,12 @@
+   A -. B            NB. items in A but not in B
+┌──────┐
+│Serena│
+└──────┘
+   A -.~ B           NB. items in B but not in A
+┌───┐
+│Jim│
+└───┘
+   A                 NB. A is a sequence without duplicates
+┌────┬──────┬───┬────┐
+│John│Serena│Bob│Mary│
+└────┴──────┴───┴────┘

Task/Symmetric-difference/J/symmetric-difference-3.j

@@ -0,0 +1,4 @@
+   A (, -. [ -. -.) B
+┌──────┬───┐
+│Serena│Jim│
+└──────┴───┘

Task/Symmetric-difference/Java/symmetric-difference.java

@@ -0,0 +1,44 @@
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class SymmetricDifference {
+    public static void main(String[] args) {
+        Set<String> setA = new HashSet<String>(Arrays.asList("John", "Serena", "Bob", "Mary", "Serena"));
+        Set<String> setB = new HashSet<String>(Arrays.asList("Jim", "Mary", "John", "Jim", "Bob"));
+
+        // Present our initial data set
+        System.out.println("In set A: " + setA);
+        System.out.println("In set B: " + setB);
+
+        // Option 1: union of differences
+        // Get our individual differences.
+        Set<String> notInSetA = new HashSet<String>(setB);
+        notInSetA.removeAll(setA);
+        Set<String> notInSetB = new HashSet<String>(setA);
+        notInSetB.removeAll(setB);
+
+        // The symmetric difference is the concatenation of the two individual differences
+        Set<String> symmetricDifference = new HashSet<String>(notInSetA);
+        symmetricDifference.addAll(notInSetB);
+
+        // Option 2: union minus intersection
+        // Combine both sets
+        Set<String> union = new HashSet<String>(setA);
+        union.addAll(setB);
+
+        // Get the intersection
+        Set<String> intersection = new HashSet<String>(setA);
+        intersection.retainAll(setB);
+
+        // The symmetric difference is the union of the 2 sets minus the intersection
+        Set<String> symmetricDifference2 = new HashSet<String>(union);
+        symmetricDifference2.removeAll(intersection);
+
+        // Present our results
+        System.out.println("Not in set A: " + notInSetA);
+        System.out.println("Not in set B: " + notInSetB);
+        System.out.println("Symmetric Difference: " + symmetricDifference);
+        System.out.println("Symmetric Difference 2: " + symmetricDifference2);
+    }
+}

Task/Symmetric-difference/JavaScript/symmetric-difference.js

@@ -0,0 +1,16 @@
+// in A but not in B
+function relative_complement(A, B) {
+    return A.filter(function(elem) {return B.indexOf(elem) == -1});
+}
+
+// in A or in B but not in both
+function symmetric_difference(A,B) {
+    return relative_complement(A,B).concat(relative_complement(B,A));
+}
+
+var a = ["John", "Serena", "Bob", "Mary", "Serena"].unique();
+var b = ["Jim", "Mary", "John", "Jim", "Bob"].unique();
+
+print(a);
+print(b);
+print(symmetric_difference(a,b));

Task/Symmetric-difference/K/symmetric-difference.k

@@ -0,0 +1,10 @@
+  A: ?("John";"Bob";"Mary";"Serena")
+  B: ?("Jim";"Mary";"John";"Bob")
+
+  A _dvl B               / in A but not in B
+"Serena"
+  B _dvl A               / in B but not in A
+"Jim"
+  (A _dvl B;B _dvl A)    / Symmetric difference
+("Serena"
+ "Jim")

Task/Symmetric-difference/Logo/symmetric-difference.logo

@@ -0,0 +1,11 @@
+to diff :a :b [:acc []]
+  if empty? :a [output sentence :acc :b]
+  ifelse member? first :a :b ~
+    [output (diff butfirst :a  remove first :a :b  :acc)] ~
+    [output (diff butfirst :a  :b    lput first :a :acc)]
+end
+
+make "a [John Bob Mary Serena]
+make "b [Jim Mary John Bob]
+
+show diff :a :b   ; [Serena Jim]

Task/Symmetric-difference/Lua/symmetric-difference.lua

@@ -0,0 +1,19 @@
+A = { ["John"] = true, ["Bob"] = true, ["Mary"] = true, ["Serena"] = true }
+B = { ["Jim"] = true, ["Mary"] = true, ["John"] = true, ["Bob"] = true }
+
+A_B = {}
+for a in pairs(A) do
+    if not B[a] then A_B[a] = true end
+end
+
+B_A = {}
+for b in pairs(B) do
+    if not A[b] then B_A[b] = true end
+end
+
+for a_b in pairs(A_B) do
+    print( a_b )
+end
+for b_a in pairs(B_A) do
+    print( b_a )
+end

Task/Symmetric-difference/MATLAB/symmetric-difference-1.m

@@ -0,0 +1,5 @@
+>> [setdiff([1 2 3],[2 3 4]) setdiff([2 3 4],[1 2 3])]
+
+ans =
+
+     1     4

Task/Symmetric-difference/MATLAB/symmetric-difference-2.m

@@ -0,0 +1,91 @@
+function resultantSet = symmetricDifference(set1,set2)
+
+    assert( ~xor(iscell(set1),iscell(set2)), 'Both sets must be of the same type, either cells or matricies, but not a combination of the two' );
+%% Helper function definitions
+
+    %Define what set equality means for cell arrays
+    function trueFalse = equality(set1,set2)
+        if xor(iscell(set1),iscell(set2)) %set1 or set2 is a set and the other isn't
+            trueFalse = false;
+            return
+        elseif ~(iscell(set1) || iscell(set2)) %set1 and set2 are not sets
+            if ischar(set1) && ischar(set2) %set1 and set2 are chars or strings
+                trueFalse = strcmp(set1,set2);
+            elseif xor(ischar(set1),ischar(set2)) %set1 or set2 is a string but the other isn't
+                trueFalse = false;
+            else %set1 and set2 are not strings
+                if numel(set1) == numel(set2) %Since they must be matricies if the are of equal cardinality then they can be compaired
+                    trueFalse = all((set1 == set2));
+                else %If they aren't of equal cardinality then they can't be equal
+                    trueFalse = false;
+                end
+            end
+            return
+        else %set1 and set2 are both sets
+
+            for x = (1:numel(set1))
+                trueFalse = false;
+                for y = (1:numel(set2))
+
+                    %Compair the current element of set1 with every element
+                    %in set2
+                    trueFalse = equality(set1{x},set2{y});
+
+                    %If the element of set1 is equal to the current element
+                    %of set2 remove that element from set2 and break out of
+                    %this inner loop
+                    if trueFalse
+                        set2(y) = [];
+                        break
+                    end
+                end
+
+                %If the loop completes without breaking then the current
+                %element of set1 is not contained in set2 therefore the two
+                %sets are not equal and we can return an equality of false
+                if (~trueFalse)
+                    return
+                end
+            end
+
+            %If, after checking every element in both sets, there are still
+            %elements in set2 then the two sets are not equivalent
+            if ~isempty(set2)
+                trueFalse = false;
+            end
+            %If the executation makes it here without the previous if
+            %statement evaluating to true, then this function will return
+            %true.
+        end
+    end %equality
+
+    %Define the relative compliment for cell arrays
+    function set1 = relativeComplement(set1,set2)
+
+        for k = (1:numel(set2))
+
+            if numel(set1) == 0
+                return
+            end
+
+            j = 1;
+            while j <= numel(set1)
+                if equality(set1{j},set2{k})
+                    set1(j) = [];
+                    j = j-1;
+                end
+                j = j+1;
+            end
+        end
+    end %relativeComplement
+
+%% The Symmetric Difference Algorithm
+    if iscell(set1) && iscell(set2)
+        resultantSet = [relativeComplement(set1,set2) relativeComplement(set2,set1)];
+    else
+        resultantSet = [setdiff(set1,set2) setdiff(set2,set1)];
+    end
+
+    resultantSet = unique(resultantSet); %Make sure there are not duplicates
+
+end %symmetricDifference

Task/Symmetric-difference/MATLAB/symmetric-difference-3.m

@@ -0,0 +1,23 @@
+>> A = {'John','Bob','Mary','Serena'}
+
+A =
+
+    'John'    'Bob'    'Mary'    'Serena'
+
+>> B = {'Jim','Mary','John','Bob'}
+
+B =
+
+    'Jim'    'Mary'    'John'    'Bob'
+
+>> symmetricDifference(A,B)
+
+ans =
+
+    'Serena'    'Jim' %Correct
+
+>> symmetricDifference([1 2 3],[2 3 4])
+
+ans =
+
+     1     4 %Correct

Task/Symmetric-difference/Mathematica/symmetric-difference-1.math

@@ -0,0 +1 @@
+SymmetricDifference[x_List,y_List] := Join[Complement[x,Intersection[x,y]],Complement[y,Intersection[x,y]]]

Task/Symmetric-difference/Mathematica/symmetric-difference-2.math

@@ -0,0 +1 @@
+CachedSymmetricDifference[x_List,y_List] := Module[{intersect=Intersection[x,y]},Join[Complement[x,intersect],Complement[y,intersect]]]

Task/Symmetric-difference/Maxima/symmetric-difference.maxima

@@ -0,0 +1,4 @@
+/* builtin */
+symmdifference({"John", "Bob", "Mary", "Serena"},
+               {"Jim", "Mary", "John", "Bob"});
+{"Jim", "Serena"}

Task/Symmetric-difference/Mercury/symmetric-difference.mercury

@@ -0,0 +1,21 @@
+:- module symdiff.
+:- interface.
+
+:- import_module io.
+:- pred main(io::di, io::uo) is det.
+
+:- implementation.
+:- import_module list, set, string.
+
+main(!IO) :-
+    A = set(["John", "Bob", "Mary", "Serena"]),
+    B = set(["Jim", "Mary", "John", "Bob"]),
+    print_set("A\\B", DiffAB @ (A `difference` B), !IO),
+    print_set("B\\A", DiffBA @ (B `difference` A), !IO),
+    print_set("A symdiff B", DiffAB `union` DiffBA, !IO).
+
+:- pred print_set(string::in, set(T)::in, io::di, io::uo) is det.
+
+print_set(Desc, Set, !IO) :-
+   to_sorted_list(Set, Elems),
+   io.format("%11s: %s\n", [s(Desc), s(string(Elems))], !IO).

Task/Symmetric-difference/OCaml/symmetric-difference-1.ocaml

@@ -0,0 +1,8 @@
+let unique lst =
+  let f lst x = if List.mem x lst then lst else x::lst in
+  List.rev (List.fold_left f [] lst)
+
+let ( -| ) a b =
+  unique (List.filter (fun v -> not (List.mem v b)) a)
+
+let ( -|- ) a b = (b -| a) @ (a -| b)

Task/Symmetric-difference/OCaml/symmetric-difference-2.ocaml

@@ -0,0 +1,14 @@
+# let a = [ "John"; "Bob"; "Mary"; "Serena" ]
+  and b = [ "Jim"; "Mary"; "John"; "Bob" ]
+  ;;
+val a : string list = ["John"; "Bob"; "Mary"; "Serena"]
+val b : string list = ["Jim"; "Mary"; "John"; "Bob"]
+
+# a -|- b ;;
+- : string list = ["Jim"; "Serena"]
+
+# a -| b ;;
+- : string list = ["Serena"]
+
+# b -| a ;;
+- : string list = ["Jim"]

Task/Symmetric-difference/Objective-C/symmetric-difference.m

@@ -0,0 +1,25 @@
+NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+NSSet* setA = [NSSet setWithObjects:@"John", @"Serena", @"Bob", @"Mary", @"Serena", nil];
+NSSet* setB = [NSSet setWithObjects:@"Jim", @"Mary", @"John", @"Jim", @"Bob", nil];
+
+// Present our initial data set
+NSLog(@"In set A: %@", setA);
+NSLog(@"In set B: %@", setB);
+
+// Get our individual differences.
+NSMutableSet* notInSetA = [NSMutableSet setWithSet:setB];
+[notInSetA minusSet:setA];
+NSMutableSet* notInSetB = [NSMutableSet setWithSet:setA];
+[notInSetB minusSet:setB];
+
+// The symmetric difference is the concatenation of the two individual differences
+NSMutableSet* symmetricDifference = [NSMutableSet setWithSet:notInSetA];
+[symmetricDifference unionSet:notInSetB];
+
+// Present our results
+NSLog(@"Not in set A: %@", notInSetA);
+NSLog(@"Not in set B: %@", notInSetB);
+NSLog(@"Symmetric Difference: %@", symmetricDifference);
+
+[pool drain];

Task/Symmetric-difference/Oz/symmetric-difference-1.oz

@@ -0,0 +1,32 @@
+declare
+  fun {SymDiff A B}
+     {Union {Diff A B} {Diff B A}}
+  end
+
+  %% implement sets in terms of lists
+  fun {MakeSet Xs}
+     set({Nub2 Xs nil})
+  end
+
+  fun {Diff set(A) set(B)}
+     set({FoldL B List.subtract A})
+  end
+
+  fun {Union set(A) set(B)}
+     set({Append A B})
+  end
+
+  %% --
+  fun {Nub2 Xs Ls}
+     case Xs of nil then nil
+     [] X|Xr andthen {Member X Ls} then {Nub2 Xr Ls}
+     [] X|Xr then X|{Nub2 Xr X|Ls}
+     end
+  end
+in
+  {Show {SymDiff
+	 {MakeSet [john bob mary serena]}
+	 {MakeSet [jim mary john bob]}}}
+  {Show {SymDiff
+	 {MakeSet [john serena bob mary serena]}
+	 {MakeSet [jim mary john jim bob]}}}

Task/Symmetric-difference/Oz/symmetric-difference-2.oz

@@ -0,0 +1,9 @@
+declare
+  fun {SymDiff A B}
+     {FS.union {FS.diff A B} {FS.diff B A}}
+  end
+
+  A = {FS.value.make [1 2 3 4]}
+  B = {FS.value.make [5 3 1 2]}
+in
+  {Show {SymDiff A B}}

Task/Symmetric-difference/PARI-GP/symmetric-difference.pari

@@ -0,0 +1,9 @@
+sd(u,v)={
+  my(r=List());
+  u=vecsort(u,,8);
+  v=vecsort(v,,8);
+  for(i=1,#u,if(!setsearch(v,u[i]),listput(r,u[i])));
+  for(i=1,#v,if(!setsearch(u,v[i]),listput(r,v[i])));
+  Vec(r)
+};
+sd(["John", "Serena", "Bob", "Mary", "Serena"],["Jim", "Mary", "John", "Jim", "Bob"])

Task/Symmetric-difference/PHP/symmetric-difference.php

@@ -0,0 +1,22 @@
+<?php
+$a = array('John', 'Bob', 'Mary', 'Serena');
+$b = array('Jim', 'Mary', 'John', 'Bob');
+
+// Remove any duplicates
+$a = array_unique($a);
+$b = array_unique($b);
+
+// Get the individual differences, using array_diff()
+$a_minus_b = array_diff($a, $b);
+$b_minus_a = array_diff($b, $a);
+
+// Simply merge them together to get the symmetric difference
+$symmetric_difference = array_merge($a_minus_b, $b_minus_a);
+
+// Present our results.
+echo 'List A:               ', implode(', ', $a),
+   "\nList B:               ", implode(', ', $b),
+  "\nA \\ B:                ", implode(', ', $a_minus_b),
+  "\nB \\ A:                ", implode(', ', $b_minus_a),
+   "\nSymmetric difference: ", implode(', ', $symmetric_difference), "\n";
+?>

Task/Symmetric-difference/Perl-6/symmetric-difference.pl6

@@ -0,0 +1,5 @@
+use Set;
+my $A = set <John Serena Bob Mary Serena>;
+my $B = set <Jim Mary John Jim Bob>;
+
+say $A (^) $B;

Task/Symmetric-difference/Perl/symmetric-difference.pl

@@ -0,0 +1,17 @@
+sub symm_diff {
+        # two lists passed in as references
+        my %in_a = map(($_=>1), @{+shift});
+        my %in_b = map(($_=>1), @{+shift});
+
+        my @a = grep { !$in_b{$_} } keys %in_a;
+        my @b = grep { !$in_a{$_} } keys %in_b;
+
+        # return A-B, B-A, A xor B as ref to lists
+        return \@a, \@b, [ @a, @b ]
+}
+
+my @a = qw(John Serena Bob  Mary Serena);
+my @b = qw(Jim  Mary   John Jim  Bob   );
+
+my ($a, $b, $s) = symm_diff(\@a, \@b);
+print "A\\B: @$a\nB\\A: @$b\nSymm: @$s\n";

Task/Symmetric-difference/PicoLisp/symmetric-difference.l

@@ -0,0 +1,2 @@
+(de symdiff (A B)
+   (uniq (conc (diff A B) (diff B A))) )

Task/Symmetric-difference/Pike/symmetric-difference-1.pike

@@ -0,0 +1,5 @@
+> multiset(string) A = (< "John", "Serena", "Bob", "Mary", "Bob", "Serena" >);
+> multiset(string) B = (< "Jim", "Mary", "Mary", "John", "Bob", "Jim" >);
+
+> A^B;
+Result: (< "Bob", "Serena", "Serena", "Mary", "Jim", "Jim" >)

Task/Symmetric-difference/Pike/symmetric-difference-2.pike

@@ -0,0 +1,7 @@
+> array(string) A = ({ "John", "Serena", "Bob", "Mary", "Serena", "Bob" });
+> array(string) B = ({ "Jim", "Mary", "John", "Jim", "Bob", "Mary" });
+> A^B;
+Result: ({ "Serena", "Serena", "Bob", "Jim", "Jim", "Mary"})
+
+> Array.uniq((A-B)+(B-A));
+Result: ({ "Serena", "Jim" })

Task/Symmetric-difference/Pike/symmetric-difference-3.pike

@@ -0,0 +1,5 @@
+> mapping(string:int) A = ([ "John":1, "Serena":1, "Bob":1, "Mary":1 ]);
+> mapping(string:int) B = ([ "Jim":1, "Mary":1, "John":1, "Bob":1 ]);
+
+> A^B;
+Result: ([ "Jim": 1, "Serena": 1 ])

Task/Symmetric-difference/Pike/symmetric-difference-4.pike

@@ -0,0 +1,4 @@
+> ADT.Set A = ADT.Set((< "John", "Serena", "Bob", "Mary", "Serena", "Bob" >));
+> ADT.Set B = ADT.Set((< "Jim", "Mary", "John", "Jim", "Bob", "Mary" >));
+> (A-B)+(B-A);
+Result: ADT.Set({ "Serena", "Jim" })

Task/Symmetric-difference/Prolog/symmetric-difference.pro

@@ -0,0 +1,15 @@
+sym_diff :-
+    A = ['John', 'Serena', 'Bob', 'Mary', 'Serena'],
+    B = ['Jim', 'Mary', 'John', 'Jim', 'Bob'],
+    format('A : ~w~n', [A]),
+    format('B : ~w~n', [B]),
+    list_to_set(A, SA),
+    list_to_set(B, SB),
+    format('set from A : ~w~n', [SA]),
+    format('set from B : ~w~n', [SB]),
+    subtract(SA, SB, DAB),
+    format('difference A\\B : ~w~n', [DAB]),
+    subtract(SB, SA, DBA),
+    format('difference B\\A : ~w~n', [DBA]),
+    union(DAB, DBA, Diff),
+    format('symetric difference : ~w~n', [Diff]).

Task/Symmetric-difference/PureBasic/symmetric-difference-1.purebasic

@@ -0,0 +1,25 @@
+Dim A.s(3)
+Dim B.s(3)
+
+A(0)="John": A(1)="Bob": A(2)="Mary": A(3)="Serena"
+B(0)="Jim":  B(1)="Mary":B(2)="John": B(3)="Bob"
+
+For a=0 To ArraySize(A())    ; A-B
+  For b=0 To ArraySize(B())
+    If A(a)=B(b)
+      Break
+    ElseIf b=ArraySize(B())
+      Debug A(a)
+    EndIf
+  Next b
+Next a
+
+For b=0 To ArraySize(B())     ; B-A
+  For a=0 To ArraySize(A())
+    If A(a)=B(b)
+      Break
+    ElseIf a=ArraySize(A())
+      Debug B(b)
+    EndIf
+  Next a
+Next b

Task/Symmetric-difference/PureBasic/symmetric-difference-2.purebasic

@@ -0,0 +1,73 @@
+DataSection
+  SetA:
+  Data.i 4
+  Data.s "John", "Bob", "Mary", "Serena"
+  ; Data.i 5
+  ; Data.s "John", "Serena", "Bob", "Mary", "Serena"
+  SetB:
+  Data.i 4
+  Data.s "Jim", "Mary", "John", "Bob"
+  ; Data.i 5
+  ; Data.s "Jim", "Mary", "John", "Jim", "Bob"
+EndDataSection
+
+Procedure addElementsToSet(List x.s())
+  ;requires the read pointer to be set prior to calling by using 'Restore'
+  Protected i, count
+
+  Read.i count
+  For i = 1 To count
+    AddElement(x())
+    Read.s x()
+  Next
+EndProcedure
+
+Procedure displaySet(List x.s())
+  Protected i, count = ListSize(x())
+  FirstElement(x())
+  For i = 1 To count
+    Print(x())
+    NextElement(x())
+    If i <> count: Print(", "): EndIf
+  Next
+  PrintN("")
+EndProcedure
+
+Procedure symmetricDifference(List a.s(), List b.s(), List result.s())
+  Protected ACount = ListSize(a()), BCount = ListSize(b()), prev.s
+
+  ;this may leave set a and b in a different order
+  SortList(a(),#PB_Sort_Ascending)
+  SortList(b(),#PB_Sort_Ascending)
+
+  FirstElement(a())
+  FirstElement(b())
+  LastElement(result()) ;add to end of result()
+  While ACount > 0 Or BCount > 0
+    If ACount <> 0 And BCount <> 0 And a() = b()
+      ACount - 1: NextElement(a())
+      BCount - 1: NextElement(b())
+    ElseIf BCount = 0 Or (ACount <> 0 And a() < b())
+      AddElement(result()): result() = a()
+      prev = a(): Repeat: ACount - 1: NextElement(a()): Until ACount = 0 Or (a() <> prev)
+    ElseIf ACount = 0 Or (BCount <> 0 And a() > b())
+      AddElement(result()): result() = b()
+      prev = b(): Repeat: BCount - 1: NextElement(b()): Until BCount = 0 Or (b() <> prev)
+    EndIf
+  Wend
+EndProcedure
+
+If OpenConsole()
+  NewList a.s(): Restore SetA: addElementsToSet(a())
+  NewList b.s(): Restore SetB: addElementsToSet(b())
+  Print("Set A: "): displaySet(a())
+  Print("Set B: "): displaySet(b())
+
+  NewList sd.s()
+  symmetricDifference(a(), b(), sd())
+  Print("Symmetric Difference: "): displaySet(sd())
+
+  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
+  Input()
+  CloseConsole()
+EndIf

Task/Symmetric-difference/Python/symmetric-difference-1.py

@@ -0,0 +1,9 @@
+>>> setA = {"John", "Bob", "Mary", "Serena"}
+>>> setB = {"Jim", "Mary", "John", "Bob"}
+>>> setA ^ setB # symmetric difference of A and B
+{'Jim', 'Serena'}
+>>> setA - setB # elements in A that are not in B
+{'Serena'}
+>>> setB - setA # elements in B that are not in A
+{'Jim'}
+>>>

Task/Symmetric-difference/Python/symmetric-difference-2.py

@@ -0,0 +1,8 @@
+>>> setA = set(["John", "Bob", "Mary", "Serena"])
+>>> setB = set(["Jim", "Mary", "John", "Bob"])
+>>> setA ^ setB # symmetric difference of A and B
+set(['Jim', 'Serena'])
+>>> setA - setB # elements in A that are not in B
+set(['Serena'])
+>>> setB - setA # elements in B that are not in A
+set(['Jim'])

Task/Symmetric-difference/R/symmetric-difference-1.r

@@ -0,0 +1,7 @@
+a <- c( "John", "Bob", "Mary", "Serena" )
+b <- c( "Jim", "Mary", "John", "Bob" )
+c(setdiff(b, a), setdiff(a, b))
+
+a <- c("John", "Serena", "Bob", "Mary", "Serena")
+b <- c("Jim", "Mary", "John", "Jim", "Bob")
+c(setdiff(b, a), setdiff(a, b))

Task/Symmetric-difference/R/symmetric-difference-2.r

@@ -0,0 +1 @@
+[1] "Jim"    "Serena"

Task/Symmetric-difference/REBOL/symmetric-difference.rebol

@@ -0,0 +1,3 @@
+a: [John Serena Bob Mary Serena]
+b: [Jim Mary John Jim Bob]
+difference a b

Task/Symmetric-difference/REXX/symmetric-difference.rexx

@@ -0,0 +1,46 @@
+/*REXX program to find the symmetric difference  (between two strings). */
+a.=0                               /*falisify all the  a.k._  booleans. */
+a= '["John", "Serena", "Bob", "Mary", "Serena"]'
+b= '["Jim", "Mary", "John", "Jim", "Bob"]'
+a.1=a;     say '──────────────list A =' a
+a.2=b;     say '──────────────list B =' b
+SD=  ;    SA=                                     /*Sym. Diff, Sym "And"*/
+SD.=0;    SA.=0                                   /*falsify SD & SA bool*/
+
+  do k=1  for 2                    /*process both lists (stemmed array).*/
+  a.k=strip(strip(a.k,,"["),,']')  /*strip leading and trailing brackets*/
+
+             do j=1  until a.k=''  /*parse names, they may have blanks. */
+             a.k=strip(a.k,,',')                  /*strip comma (if any)*/
+             parse var a.k '"' _ '"' a.k          /*get the list's name.*/
+             a.k.j=_                              /*store the list name.*/
+             a.k._=1                              /*make a boolean val. */
+             end   /*j*/
+  a.k.0=j-1                                       /*number of list names*/
+  end              /*k*/
+/*══════════════════════════════════════════════════find symmetric diff.*/
+  do k=1  for 2                                   /*process both lists. */
+  ko=word(2 1,k)                                  /*point to other list.*/
+
+      do j=1  for a.k.0;      _=a.k.j             /*process list names. */
+      if \a.ko._ & \SD._ then do                  /*if not in both...   */
+                              SD=SD '"'_'",'      /*add to sym diff list*/
+                              SD._=1              /*"trueify" a boolean.*/
+                              end
+      end   /*j*/
+  end       /*k*/
+
+SD= "["strip(space(SD),'T',",")']'                /*clean up and bracket*/
+say;          say 'symmetric difference =' SD     /*show and tell the SD*/
+
+/*══════════════════════════════════════════════════find symmetric AND. */
+  do j=1  for a.1.0;            _=a.1.j           /*process A list names*/
+  if a.1._ & a.2._ & \SA._ then do                /*if common to both...*/
+                                SA=SA '"'_'",'    /*add to sym AND list.*/
+                                SA._=1            /*"trueify" a boolean.*/
+                                end
+  end   /*j*/
+
+SA="["strip(space(SA),'T',",")']'                 /*clean up and bracket*/
+say;          say '       symmetric AND =' SA     /*show and tell the SA*/
+                                       /*stick a fork in it, we're done.*/

Task/Symmetric-difference/Racket/symmetric-difference.rkt

@@ -0,0 +1,7 @@
+#lang racket
+(define A (set "John" "Bob" "Mary" "Serena"))
+(define B (set "Jim" "Mary" "John" "Bob"))
+
+(set-symmetric-difference A B)
+(set-subtract A B)
+(set-subtract B A)

Task/Symmetric-difference/Ruby/symmetric-difference-1.rb

@@ -0,0 +1,10 @@
+# with sets
+require 'set'
+a = Set["John", "Serena", "Bob", "Mary", "Serena"]
+b = Set["Jim", "Mary", "John", "Jim", "Bob"]
+
+# or, with arrays
+a = ["John", "Serena", "Bob", "Mary", "Serena"]
+b = ["Jim", "Mary", "John", "Jim", "Bob"]
+a.uniq!
+b.uniq!

Task/Symmetric-difference/Ruby/symmetric-difference-2.rb

@@ -0,0 +1,3 @@
+a_not_b = a - b
+b_not_a = b - a
+sym_diff = a_not_b + b_not_a

Task/Symmetric-difference/Ruby/symmetric-difference-3.rb

@@ -0,0 +1 @@
+sym_diff = a ^ b

Task/Symmetric-difference/SQL/symmetric-difference-1.sql

@@ -0,0 +1,14 @@
+create or replace function arrxor(anyarray,anyarray) returns anyarray as $$
+select ARRAY(
+        (
+        select r.elements
+        from    (
+                (select 1,unnest($1))
+                union all
+                (select 2,unnest($2))
+                ) as r (arr, elements)
+        group by 1
+        having min(arr) = max(arr)
+        )
+)
+$$ language sql strict immutable;

Task/Symmetric-difference/SQL/symmetric-difference-2.sql

@@ -0,0 +1 @@
+select arrxor('{this,is,a,test}'::text[],'{also,part,of,a,test}'::text[]);

Task/Symmetric-difference/Scala/symmetric-difference.scala

@@ -0,0 +1,8 @@
+scala> val s1 = Set("John", "Serena", "Bob", "Mary", "Serena")
+s1: scala.collection.immutable.Set[java.lang.String] = Set(John, Serena, Bob, Mary)
+
+scala> val s2 = Set("Jim", "Mary", "John", "Jim", "Bob")
+s2: scala.collection.immutable.Set[java.lang.String] = Set(Jim, Mary, John, Bob)
+
+scala> (s1 diff s2) union (s2 diff s1)
+res46: scala.collection.immutable.Set[java.lang.String] = Set(Serena, Jim)

Task/Symmetric-difference/Seed7/symmetric-difference.seed7

@@ -0,0 +1,13 @@
+$ include "seed7_05.s7i";
+
+const type: striSet is set of string;
+
+enable_output(striSet);
+
+const proc: main is func
+  local
+    const striSet: setA is {"John", "Bob" , "Mary", "Serena"};
+    const striSet: setB is {"Jim" , "Mary", "John", "Bob"   };
+  begin
+    writeln(setA >< setB);
+  end func;

Task/Symmetric-difference/Smalltalk/symmetric-difference.st

@@ -0,0 +1,7 @@
+|A B|
+A := Set new.
+B := Set new.
+A addAll: #( 'John' 'Bob' 'Mary' 'Serena' ).
+B addAll: #( 'Jim' 'Mary' 'John' 'Bob' ).
+
+( (A - B) + (B - A) ) displayNl.

Task/Symmetric-difference/TUSCRIPT/symmetric-difference.tuscript

@@ -0,0 +1,22 @@
+$$ MODE TUSCRIPT
+a="John'Bob'Mary'Serena"
+b="Jim'Mary'John'Bob"
+
+DICT names CREATE
+
+SUBMACRO checknames
+!var,val
+PRINT val,": ",var
+ LOOP n=var
+  DICT names APPEND/QUIET n,num,cnt,val;" "
+ ENDLOOP
+ENDSUBMACRO
+
+CALL checknames (a,"a")
+CALL checknames (b,"b")
+
+DICT names UNLOAD names,num,cnt,val
+
+LOOP n=names,v=val
+PRINT n," in: ",v
+ENDLOOP

Task/Symmetric-difference/Tcl/symmetric-difference.tcl

@@ -0,0 +1,15 @@
+package require struct::set
+
+set A {John Bob Mary Serena}
+set B {Jim Mary John Bob}
+
+set AnotB   [struct::set difference $A $B]
+set BnotA   [struct::set difference $B $A]
+set SymDiff [struct::set union $AnotB $BnotA]
+
+puts "A\\B = $AnotB"
+puts "B\\A = $BnotA"
+puts "A\u2296B = $SymDiff"
+
+# Of course, the library already has this operation directly...
+puts "Direct Check: [struct::set symdiff $A $B]"

Task/Symmetric-difference/UNIX-Shell/symmetric-difference.sh

@@ -0,0 +1,43 @@
+uniq() {
+  u=("$@")
+  for ((i=0;i<${#u[@]};i++)); do
+    for ((j=i+1;j<=${#u[@]};j++)); do
+      [ "${u[$i]}" = "${u[$j]}" ] && unset u[$i]
+    done
+  done
+  u=("${u[@]}")
+}
+
+a=(John Serena Bob Mary Serena)
+b=(Jim Mary John Jim Bob)
+
+uniq "${a[@]}"
+au=("${u[@]}")
+uniq "${b[@]}"
+bu=("${u[@]}")
+
+ab=("${au[@]}")
+for ((i=0;i<=${#au[@]};i++)); do
+  for ((j=0;j<=${#bu[@]};j++)); do
+    [ "${ab[$i]}" = "${bu[$j]}" ] && unset ab[$i]
+  done
+done
+ab=("${ab[@]}")
+
+ba=("${bu[@]}")
+for ((i=0;i<=${#bu[@]};i++)); do
+  for ((j=0;j<=${#au[@]};j++)); do
+    [ "${ba[$i]}" = "${au[$j]}" ] && unset ba[$i]
+  done
+done
+ba=("${ba[@]}")
+
+sd=("${ab[@]}" "${ba[@]}")
+
+echo "Set A = ${a[@]}"
+echo "      = ${au[@]}"
+echo "Set B = ${b[@]}"
+echo "      = ${bu[@]}"
+echo "A - B = ${ab[@]}"
+echo "B - A = ${ba[@]}"
+echo "Symmetric difference = ${sd[@]}"

Task/Symmetric-difference/Ursala/symmetric-difference.ursala

@@ -0,0 +1,13 @@
+a = <'John','Bob','Mary','Serena'>
+b = <'Jim','Mary','John','Bob'>
+
+#cast %sLm
+
+main =
+
+<
+   'a': a,
+   'b': b,
+   'a not b': ~&j/a b,
+   'b not a': ~&j/b a,
+   'symmetric difference': ~&jrljTs/a b>