Symmetric difference: Difference between revisions

 

 

 

 

 

 

 

 

 

=={{header|Ada}}==

 

procedure Test_XOR is

Put ("A - B = "); Put (A and not B); New_Line;

Put ("B - A = "); Put (B and not A); New_Line;

Sample output:

<pre>

B - A = JIM

</pre>

=={{header|AutoHotkey}}==

setB = Jim, Mary, John, Bob

MsgBox,, Singles, % SymmetricDifference(setA, setB)

setB = Jim, Mary, John, Jim, Bob

MsgBox,, Duplicates, % SymmetricDifference(setA, setB)

 

;---------------------------------------------------------------------------

Result .= B_%A_Index% ", "

Return, SubStr(Result, 1, -2)

Message boxes show:

<pre>Singles

OK</pre>

 

}

 

 

 

 

 

 

 

#include <string.h>

#include <stdlib.h>

 

 

const char *setA[] = {john,bob,mary,serena};

}

 

 

void printSet (const char *set[], int ssize)

const char **symset;

int sysize;

 

printf ("A symmdiff B");

 

return 0;

Output

A symmdiff B = {Serena Jim }

A - B = {Serena }

B - A = {Jim }

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

using System.Collections.Generic;

using System.Linq;

}

}

Output:

=={{header|C++}}==

#include <set>

#include <algorithm>

#include <iterator>

 

int main( ) {

Output:

Jim Serena

 

=={{header|Clojure}}==

 

(defn symmetric-difference [s1 s2]

(union (difference s1 s2) (difference s2 s1)))

 

 

=={{header|Common Lisp}}==

 

=={{header|D}}==

 

 

 

}

 

return (left - right) + (right - left);

}

 

 

Output:

 

 

 

=={{header|F Sharp|F#}}==

let b = set ["Jim"; "Mary"; "John"; "Bob"];;

 

 

> (a-b) + (b-a);;

Or, if you don't like the infix operators:

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

end do outer2

Output

 

 

=={{header|GAP}}==

return Union(Difference(a, b), Difference(b, a));

end;

b := ["Jim", "Mary", "John", "Jim", "Bob"];

SymmetricDifference(a,b);

 

 

 

a = fromList ["John", "Bob", "Mary", "Serena"]

 

(-|-) :: Ord a => Set a -> Set a -> Set a

Symmetric difference:

Individual differences:

fromList ["Serena"]

 

*Main> b \\ a

 

=={{header|HicEst}}==

CALL SymmDiff("John,Bob,Mary,Serena,", "Jim,Mary,John,Bob,")

 

EDIT(Text=a, Option=1, SortDelDbls=a) ! Option=1: keep case; Serena,

differences = TRIM( differences ) // a

 

Set operations are built into Icon/Unicon.

 

a := set(["John", "Serena", "Bob", "Mary", "Serena"])

write("}")

return

b = { Mary Bob Jim John }

(a\b) ∩ (b\a) = { Serena Jim }

(a\b) = { Serena }

(b\a) = { Jim }</pre>

 

=={{header|J}}==

 

┌──────┬───┐

│Serena│Jim│

└──────┴───┘

┌──────┬───┐

│Serena│Jim│

┌──────┐

│Serena│

└──────┘

┌───┐

│Jim│

 

=={{header|Java}}==

import java.util.HashSet;

import java.util.Set;

System.out.println("In set B: " + setB);

 

// Get our individual differences.

Set<String> notInSetA = new HashSet<String>(setB);

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);

// 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);

}

In set B: [Mary, Bob, Jim, John]

Not in set A: [Jim]

Not in set B: [Serena]

Symmetric Difference: [Jim, Serena]

 

=={{header|JavaScript}}==

{{works with|JavaScript|1.6}}

{{works with|Firefox|1.5}}

{{works with|SpiderMonkey}} for the <code>print()</code> function.

 

Uses the Array function <code>unique()</code> defined [[Create a Sequence of unique elements#JavaScript|here]].

function relative_complement(A, B) {

return A.filter(function(elem) {return B.indexOf(elem) == -1});

print(a);

print(b);

outputs

<pre>Bob,John,Mary,Serena

Bob,Jim,John,Mary

Serena,Jim</pre>

 

=={{header|Logo}}==

{{works with|UCB Logo}}

if empty? :a [output sentence :acc :b]

ifelse member? first :a :b ~

make "b [Jim Mary John Bob]

 

=={{header|Lua}}==

B = { ["Jim"] = true, ["Mary"] = true, ["John"] = true, ["Bob"] = true }

 

for b_a in pairs(B_A) do

print( b_a )

 

=={{header|MATLAB}}==

If you are using a vector of numbers as the sets of which you like to find the symmetric difference, then there are already utilities that operate on these types of sets built into MATLAB. This code will take the symmetric difference of two vectors:

 

ans =

 

On the other hand, if you are using cell-arrays as sets, there are no built-in set utilities to operate on those data structures, so you will have to program them yourself. Also, the only way to have a set of strings is to put each string in a cell of a cell array, trying to put them into a vector will cause all of the strings to concatenate.

 

This code will return the symmetric difference of two sets and will take both cell arrays and vectors (as in the above example) as inputs.

 

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' );

end %equality

function set1 = relativeComplement(set1,set2)

resultantSet = unique(resultantSet); %Make sure there are not duplicates

Solution Test:

 

A =

ans =

 

 

=={{header|OCaml}}==

 

let ( -| ) a b =

unique (List.filter (fun v -> not (List.mem v b)) a)

 

in the toplevel:

and b = [ "Jim"; "Mary"; "John"; "Bob" ]

;;

 

# b -| a ;;

 

=={{header|Oz}}==

Oz does not have a general set data type. We can implement some basic set operations in terms of list functions and use them to define the symmetric difference:

fun {SymDiff A B}

{Union {Diff A B} {Diff B A}}

{Show {SymDiff

{MakeSet [john serena bob mary serena]}

Oz <em>does</em> have a type for finite sets of non-negative integers. This is part of the constraint programming support. For the given task, we could use it like this if we assume numbers instead of names:

fun {SymDiff A B}

{FS.union {FS.diff A B} {FS.diff B A}}

B = {FS.value.make [5 3 1 2]}

in

 

 

 

 

 

 

 

 

 

 

 

 

 

}

 

 

 

$a = array('John', 'Bob', 'Mary', 'Serena');

$b = array('Jim', 'Mary', 'John', 'Bob');

"\nB \\ A: ", implode(', ', $b_minus_a),

"\nSymmetric difference: ", implode(', ', $symmetric_difference), "\n";

This outputs:

<pre>List A: John, Bob, Mary, Serena

List B: Jim, Mary, John, Bob

B \ A: Jim

Symmetric difference: Serena, Jim</pre>

 

=={{header|PicoLisp}}==

Output:

<pre>(symdiff '(John Serena Bob Mary Serena) '(Jim Mary John Jim Bob))

-> (Serena Jim)</pre>

 

=={{header|Prolog}}==

A = ['John', 'Serena', 'Bob', 'Mary', 'Serena'],

B = ['Jim', 'Mary', 'John', 'Jim', 'Bob'],

format('difference B\\A : ~w~n', [DBA]),

union(DAB, DBA, Diff),

output :

B : [Jim,Mary,John,Jim,Bob]

set from A : [John,Serena,Bob,Mary]

difference B\A : [Jim]

symetric difference : [Serena,Jim]

 

=={{header|PureBasic}}==

===Simple approach===

Dim B.s(3)

 

EndIf

Next a

===Solution using lists===

SetA:

Data.i 4

Input()

CloseConsole()

Sample output:

<pre>Set A: John, Bob, Mary, Serena

 

=={{header|Python}}==

>>> setB = set(["Jim", "Mary", "John", "Bob"])

>>> setA ^ setB # symmetric difference of A and B

>>> setA - setB # elements in A that are not in B

set(['Serena'])

 

=={{header|R}}==

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")

In both cases answer is:

 

=={{header|REBOL}}==

b: [Jim Mary John Jim Bob]

Result is

<pre>

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

Output:

 

 

</pre>

 

=={{header|Ruby}}==

b = Set["Jim", "Mary", "John", "Jim", "Bob"]

 

 

 

=={{header|Scala}}==

 

 

 

 

 

<pre>

</pre>

 

=={{header|Smalltalk}}==

A := Set new.

B := Set new.

B addAll: #( 'Jim' 'Mary' 'John' 'Bob' ).

 

Output is

<pre>

Set ('Jim' 'Serena' )

</pre>

 

=={{header|Tcl}}==

It's common to represent sets as an unordered list of elements. (It is also the most efficient representation.) The <code>struct::set</code> package contains operations for working on such sets-as-lists.

{{tcllib|struct::set}}

 

set A {John Bob Mary Serena}

 

# Of course, the library already has this operation directly...

Produces this output:<pre>

A\B = Serena

Direct Check: Jim Serena

</pre>

 

=={{header|Ursala}}==

b = <'Jim','Mary','John','Bob'>

 

'a not b': ~&j/a b,

'b not a': ~&j/b a,

output:

<pre><

'b not a': <'Jim'>,

'symmetric difference': <'Jim','Serena'>></pre>