Symmetric difference: Difference between revisions

# 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'').

<br><br>

=={{header|Ada}}==

Ada has the lattice operation '''xor''' predefined on Boolean, modular types, 1D arrays, set implementations from the standard library. The provided solution uses arrays:

 

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>

 

=={{header|Aime}}==

{

record r;

 

0;

{{out}}

<pre>Jim

Serena</pre>

 

=={{header|Apex}}==

Set<String> setB = new Set<String>{'Jim', 'Mary', 'John', 'Bob'};

 

System.debug('Not in set B: ' + notInSetB);

System.debug('Symmetric Difference: ' + symmetricDifference);

{{out}}

<pre>Not in set A: {Jim}

Symmetric Difference 2: {Jim, Serena}</pre>

 

 

=={{header|AppleScript}}==

{{Trans|JavaScript}} (ES6 Functional JS)

 

-- symmetricDifference :: [a] -> [a] -> [a]

set sx to nub(xs)

sx & foldl(flipDelete, nub(ys), sx)

{{Out}}

 

 

 

 

 

 

 

=={{header|AutoHotkey}}==

setB = Jim, Mary, John, Bob

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

Result .= B_%A_Index% ", "

Return, SubStr(Result, 1, -2)

Message boxes show:

<pre>Singles

 

=={{header|AWK}}==

# syntax: GAWK -f SYMMETRIC_DIFFERENCE.AWK

BEGIN {

printf("\n")

}

<p>output:</p>

<pre>

=={{header|BBC BASIC}}==

Here sets are represented as integers, hence there are a maximum of 32 elements in a set.

list$() = "Bob", "Jim", "John", "Mary", "Serena"

IF set% AND 1 << i% o$ += list$(i%) + ", "

NEXT

'''Output:'''

<pre>

Walk through the concatenation of the two lists, using backtracking (forced by the ~ operator).

If an element is in both lists, or if the element already is in the accumulated result <code>symdiff</code>, continue. Otherwise add the element to <code>symdiff</code>. When all elements are done and backtracking therefore finally fails, return the contents of <code>symdiff</code>. The flag <code>%</code> in the pattern <code>%@?x</code> ensures that only nontrivial elements (i.e. non-empty strings in this case) are matched. The <code>@</code> flag ensures that at most one string is matched. Together these flags ensure that exactly one element is matched.

A B x symdiff

. !arg:(?A.?B)

?

| !symdiff

Run:

Output:

 

=={{header|C}}==

Simple method:

#include <string.h>

 

 

return 0;

<pre>

A \ B:

</pre>

If you prefer something elaborate:

#include <stdio.h>

#include <string.h>

 

return 0;

Output

<pre>

 

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

using System.Collections.Generic;

using System.Linq;

}

}

Output:

<pre>

 

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

#include <set>

#include <algorithm>

cout << endl;

return 0;

 

Output:

 

=={{header|Clojure}}==

 

(defn symmetric-difference [s1 s2]

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

 

 

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

(remove-duplicates '(John Serena Bob Mary Serena))

Output:

(JIM SERENA)

=={{header|D}}==

Generic version.

 

struct Set(T) {

writeln(" B\\A: ", (B - A).items);

writeln("A symdiff B: ", symmetricDifference(A, B).items);

{{out}}

<pre> A\B: ["Serena"]

B\A: ["Jim"]

A symdiff B: ["Serena", "Jim"]</pre>

 

=={{header|Déjà Vu}}==

Déjà Vu has no real set type. Instead, it uses a dictionary whose keys are the set values. The <code>set{</code> constructor uses <code>true</code> as a dummy value, and sets <code>false</code> as a dummy value.

set :setB set{ :Jim :Mary :John :Bob }

 

set{

 

{{out}}

<pre>set{ :Serena :Jim }</pre>

 

=={{header|E}}==

# value: <symmDiff>

 

? symmDiff(["John", "Bob", "Mary", "Serena"].asSet(), ["Jim", "Mary", "John", "Bob"].asSet())

 

 

=={{header|Eiffel}}==

description: "Summary description for {SYMETRIC_DIFFERENCE_EXAMPLE}."

URI: "http://rosettacode.org/wiki/Symmetric_difference"

end

 

 

=={{header|Factor}}==

[ diff ] [ swap diff ] 2bi append ;

 

 

=={{header|Forth}}==

GForth 0.7.0 tested.

[ cell 8 * 1- ] literal umin CREATE 1 swap lshift ,

DOES> ( -- 2^n ) @ ;

swap -1 xor and cr persons

cr bye

Output:

<pre>

=={{header|Fortran}}==

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

implicit none

 

end do outer2

Output

<pre>

Serena

Jim

</pre>

 

=={{header|GAP}}==

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

end;

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

SymmetricDifference(a,b);

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println(sd)

Output:

<pre>

</pre>

Alternatively, the following computes destructively on a. The result is the same.

for e := range b {

delete(a, e)

}

fmt.Println(a)

 

=={{header|Groovy}}==

Solution:

assert s1 != null

assert s2 != null

(s1 + s2) - (s1.intersect(s2))

Test:

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

 

ppm <> csny: ${PC}

ppm <> ppm: ${PP}

 

Output:

 

=={{header|Haskell}}==

 

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

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

x -|- y = (x \\ y) `union` (y \\ x)

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

 

=={{header|Icon}} and {{header|Unicon}}==

Set operations are built into Icon/Unicon.

 

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

write("}")

return

Sample output:

<pre>a = { Serena Mary Bob John }

 

=={{header|J}}==

B=: ~. ;:'Jim Mary John Jim Bob'

 

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

│Serena│Jim│

To illustrate some of the underlying mechanics used here:

┌──────┐

│Serena│

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

│John│Serena│Bob│Mary│

Here's an alternative implementation:

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

│Serena│Jim│

Here, <code>(,)</code> contains all items from A and B and <code>([ -. -.)</code> is the idiom for set intersection, and their difference is the symmetric difference. (Note: an individual word in a J sentence may be placed inside a parenthesis with no change in evaluation, and this can also be used for emphasis when a word might get lost.)

 

=={{header|Java}}==

import java.util.HashSet;

import java.util.Set;

System.out.println("Symmetric Difference 2: " + symmetricDifference2);

}

Output:

<pre>In set A: [Mary, Bob, Serena, John]

 

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

'''Clear JavaScript'''

 

{

var a = A.length, b = B.length, c = 0, C = [];

Difference(B,A); // 'Jim'

SymmetricDifference(A,B); // 'Serena','Jim'

 

===ES6===

====Functional====

By composition of generic functions;

'use strict';

 

symmetricDifference(a, b)

);

{{Out}}

====Procedural ====

const symmetricDifference = (...args) => {

let result = new Set();

console.log(symmetricDifference([1, 2, 5], [2, 3, 5], [3, 4, 5]));

 

{{Out}}

[1, 4, 5]

 

=={{header|jq}}==

given these assumptions, it is quite efficient. To workaround the

no-null requirement would be tedious but straightforward.

# elements of a (and of b) are unique and do not include null:

def intersection(a; b):

(a|unique) as $a | (b|unique) as $b

| (($a + $b) | unique) - (intersection($a;$b));

 

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

Built-in function.

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

 

{{out}}

 

=={{header|K}}==

B: ?("Jim";"Mary";"John";"Bob")

 

(A _dvl B;B _dvl A) / Symmetric difference

("Serena"

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

val e = c.union(d)

println("A Δ B = $e")

 

{{out}}

A Δ B = [Serena, Jim]

</pre>

 

=={{header|Lasso}}==

[

var(

 

]

 

=={{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 )

 

Object-oriented approach:

 

__index = {

union = function(self, other)

print("Intersection A∩B : " .. A:intersection(B))

print("Difference A\\B : " .. A:difference(B))

 

'''Output:'''

=={{header|Maple}}==

Maple has built-in support for set operations. Assign the sets A and B:

Now compute the symmetric difference with the '''symmdiff''' command:

{{out}}

{Jim, Serena}

 

Mathematica has built-in support for operations on sets, using its generic symbolic lists. This function finds the entries in each list that are not present in the intersection of the two lists.

For large lists, some performance improvement could be made by caching the intersection of the two lists to avoid computing it twice:

Also, due to Mathematica's symbolic nature, these functions are automatically applicable to lists of any content, such as strings, integers, reals, graphics, or undefined generic symbols (e.g. unassigned variables).

 

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

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

Solution Test:

 

A =

ans =

 

 

=={{header|Maxima}}==

symmdifference({"John", "Bob", "Mary", "Serena"},

{"Jim", "Mary", "John", "Bob"});

 

=={{header|Mercury}}==

:- interface.

 

print_set(Desc, Set, !IO) :-

to_sorted_list(Set, Elems),

 

=={{header|Nim}}==

 

Output:

<pre>{Serena, Jim}

 

=={{header|Objective-C}}==

 

int main(int argc, const char *argv[]) {

}

return 0;

 

=={{header|OCaml}}==

let f lst x = if List.mem x lst then lst else x::lst in

List.rev (List.fold_left f [] lst)

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

 

in the toplevel:

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

;;

 

# b -| a ;;

 

=={{header|ooRexx}}==

b = .set~of("Jim", "Mary", "John", "Bob")

-- the xor operation is a symmetric difference

do item over a~xor(b)

say item

Output:

<pre>

=={{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

 

=={{header|Pascal}}==

{{works with|FPC 3.0.2}}

 

TYPE

Put('ListA -> ', ListA);

Put('ListB -> ', ListB);

Put('ListA - ListB -> ', ListA - ListB);

Put('ListB - ListA -> ', ListB - ListA);

ReadLn;

{{out}}

<pre>ListA -> Bob John Mary Serena

ListA - ListB -> Serena

ListB - ListA -> Jim</pre>

 

 

=={{header|Perl}}==

# two lists passed in as references

my %in_a = map(($_=>1), @{+shift});

 

my ($a, $b, $s) = symm_diff(\@a, \@b);

{{out}}

<pre>A\B: Serena

B\A: Jim

Symm: Serena Jim</pre>

 

=={{header|Phix}}==

{{Out}}

<pre>

{}

</pre>

 

=={{header|PHP}}==

$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

B \ A: Jim

Symmetric difference: Serena, Jim</pre>

 

=={{header|PicoLisp}}==

Output:

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

=={{header|Pike}}==

The set type in Pike is 'multiset', that is, a value may appear multiple times and the difference operator only removes equal amounts of duplicates.

> multiset(string) B = (< "Jim", "Mary", "Mary", "John", "Bob", "Jim" >);

 

> A^B;

The <code>^</code> operator treats arrays like multisets.

> array(string) B = ({ "Jim", "Mary", "John", "Jim", "Bob", "Mary" });

> A^B;

 

> Array.uniq((A-B)+(B-A));

Set operations are also possible with mappings. Here the difference operator works as expected:

> mapping(string:int) B = ([ "Jim":1, "Mary":1, "John":1, "Bob":1 ]);

 

> A^B;

Lastly, there is a Set class.

> ADT.Set B = ADT.Set((< "Jim", "Mary", "John", "Jim", "Bob", "Mary" >));

> (A-B)+(B-A);

 

=={{header|PL/I}}==

* 17.08.2013 Walter Pachl

**********************************************************************/

End;

End;

Output:

<pre>

 

=={{header|PowerShell}}==

"Bob"

"Mary"

# B - A

{{out}}

<pre>InputObject SideIndicator

=={{header|Prolog}}==

{{Works with|SWI-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 :

<pre>A : [John,Serena,Bob,Mary,Serena]

=={{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

'''Python 3.x''' and '''Python 2.7''' have syntax for set literals:

 

>>> setB = {"Jim", "Mary", "John", "Bob"}

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

{'John', 'Bob', 'Jim', 'Serena', 'Mary'}

>>> setA & setB # elements in both A and B (intersection)

 

Note that the order of set elements is undefined.

Earlier versions of 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'])

 

There is also a method call interface for these operations. In contrast to the operators above, they accept any iterables as arguments not just sets.

 

{'Jim', 'Serena'}

>>> setA.difference(setB)

{'Jim', 'Mary', 'Serena', 'John', 'Bob'}

>>> setA.intersection(setB)

 

=={{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|Racket}}==

 

#lang racket

(define A (set "John" "Bob" "Mary" "Serena"))

(set-subtract A B)

(set-subtract B A)

 

=={{header|REBOL}}==

b: [Jim Mary John Jim Bob]

Result is

<pre>

</pre>

 

=={{header|REXX}}==

===version 1===

 

The &nbsp; '''set''' &nbsp; elements may contain any character permitted with a REXX literal, including the literal character itself (expressed as a double literal delimiter), blanks, brackets, commas, and also a &nbsp; ''null'' &nbsp; value.

a= '["John", "Serena", "Bob", "Mary", "Serena"]' /*note the duplicate element: Serena */

b= '["Jim", "Mary", "John", "Jim", "Bob"]' /* " " " " Jim */

say /* [↓] SA ≡ symmetric AND. */

SA= "["strip( strip(SA), 'T', ",")']' /*clean up and add brackets [ ] to it.*/

{{out|output|text=&nbsp; when using the in-program lists:}}

<pre>

===version 1.5===

This REXX version shows the symmetric difference and symmetric AND between two lists, the lists have items that have imbedded blanks in them as well as some punctuation, and also a ''null'' element.

a.=0 /*falsify the booleans*/

a= '["Zahn", "Yi", "Stands with a Fist", "", "Hungry Wolf", "Yi"]'

∙

∙

{{out|output|text=&nbsp; when using the in-program lists (which has imbedded blanks):}}

<pre>

 

===version 2===

* 14.12.2013 Walter Pachl a short solution

* 16.12.2013 fix duplicate element problem in input

out: parse Arg e

If wordpos(e,res)=0 Then res=res e

Output:

<pre>Serena Jim</pre>

 

=={{header|Ring}}==

alist = []

blist = []

see "b-a :" see nl

see blist2 see nl

 

=={{header|Ruby}}==

With arrays:

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

# the union minus the intersection:

Class Set has a symmetric difference operator built-in:

a = Set["John", "Serena", "Bob", "Mary", "Serena"] #Set removes duplicates

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

 

=={{header|Run BASIC}}==

setA$ = "John,Bob,Mary,Serena"

setB$ = "Jim,Mary,John,Bob"

i = i + 1

wend

<pre>

Jim

Serena

Jim,Serena

</pre>

 

=={{header|Scala}}==

s1: scala.collection.immutable.Set[java.lang.String] = Set(John, Serena, Bob, Mary)

 

 

scala> (s1 diff s2) union (s2 diff s1)

 

=={{header|Scheme}}==

In pure Scheme, to illustrate implementation of the algorithms:

 

(import (scheme base)

(scheme write))

(display (symmetric-difference '(John Serena Bob Mary Serena)

'(Jim Mary John Jim Bob))) (newline)

 

{{out}}

SRFI 1 is one of the most popular SRFIs. It deals with lists, but also has functions treating lists as sets. The lset functions assume the inputs are sets, so we must delete duplicates if this property is not guaranteed on input.

 

(import (scheme base)

(scheme write)

(display (symmetric-difference '(John Serena Bob Mary Serena)

'(Jim Mary John Jim Bob))) (newline)

 

=={{header|Seed7}}==

 

const type: striSet is set of string;

begin

writeln(setA >< setB);

 

Output:

{Jim, Serena}

</pre>

 

=={{header|Sidef}}==

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

{{out}}

<pre>

 

=={{header|Smalltalk}}==

A := Set new.

B := Set new.

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

 

Output is

<pre>

 

=={{header|SQL}}/{{header|PostgreSQL}}==

select ARRAY(

(

)

)

Usage:

Output:

<pre>

Swift's <code>Set</code> type supports difference as well as symmetric difference operators.

{{works with|Swift|1.2+}}

let setB : Set<String> = ["Jim", "Mary", "John", "Bob"]

println(setA.exclusiveOr(setB)) // symmetric difference of A and B

{{out}}

<pre>

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

 

=={{header|TUSCRIPT}}==

a="John'Bob'Mary'Serena"

b="Jim'Mary'John'Bob"

LOOP n=names,v=val

PRINT n," in: ",v

Output:

<pre>

=={{header|UNIX Shell}}==

{{works with|Bash}}

u=("$@")

for ((i=0;i<${#u[@]};i++)); do

echo "A - B = ${ab[@]}"

echo "B - A = ${ba[@]}"

Output:

<pre>Set A = John Serena Bob Mary Serena

 

=={{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>

 

=={{header|Yabasic}}==

lista2$ = "Jim Mary John Jim Bob"

 

wend

end sub

 

=={{header|zkl}}==

fcn sdiff(list1,list2)

b:=T("Jim","Mary","John","Bob");

To deal with duplicates, use [[Remove duplicate elements#zkl]]:

b:=T("Jim", "Mary", "John", "Jim", "Bob");

{{out}}

<pre>