15
\$\begingroup\$

Surprised that we don't have a symmetric difference challenge yet.

Given two lists only containing positive integers, return all items among these two lists that aren't contained in both of the lists.

Rules

From the set definition:

A set is a collection of definite distinct items.

  • So you can assume the items in the input lists are always unique.
  • You can also take input as a set if your language supports it.

Test cases

Here is a sample program that generates the test cases.

[1,2,3],[2,3,4] -> [1,4]
\$\endgroup\$
  • \$\begingroup\$ C++ has a builtin but it doesn't work. I'm going to go ask on Stack Overflow. \$\endgroup\$ – S.S. Anne Apr 14 at 16:25

22 Answers 22

1
\$\begingroup\$

Jelly, 2 bytes

œ^

It's a two-byte dyadic atom (i.e. a built-in).

Try it online!

| improve this answer | |
\$\endgroup\$
12
\$\begingroup\$

APL (Dyalog Unicode), 3 bytes

∪~∩

Try it online!

How it works

∪~∩  ⍝ Input: two sets as vectors
∪    ⍝ Set union
 ~   ⍝ Set minus
  ∩  ⍝ Set intersection

The rest is just for fun.

APL (Dyalog Unicode), 4 bytes

~∪~⍨

Try it online!

~∪~⍨
~     ⍝ Set difference (a~b)
 ∪    ⍝ Set union
  ~⍨  ⍝ Set difference reversed (b~a)

APL (Dyalog Unicode), 5 bytes

~⍨∪⍨~

Try it online!

This one is palindromic!

How it works

~⍨∪⍨~
~⍨     ⍝ Set difference reversed (b~a)
  ∪⍨   ⍝ Set union reversed
    ~  ⍝ Set difference (a~b)
| improve this answer | |
\$\endgroup\$
  • 7
    \$\begingroup\$ The only symmetric answer so far. \$\endgroup\$ – Adám Apr 12 at 12:58
9
\$\begingroup\$

Python 3, 11 bytes

set.__xor__

Try it online!

For built-in set objects, a^b computes symmetrical set difference. __xor__ is the magic name for that operator, and it is shorter than lambda a,b:a^b.

Also works in Python 2.

| improve this answer | |
\$\endgroup\$
5
\$\begingroup\$

J, 8 6 bytes

-2 bytes thanks to Bubbler!

-.,-.~

Try it online!

K (oK), 11 bytes

{(x^y),y^x}

Try it online!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Shouldn't -.,-.~ work in J? \$\endgroup\$ – Bubbler Apr 12 at 11:24
  • \$\begingroup\$ @Bubbler Yes, thanks! \$\endgroup\$ – Galen Ivanov Apr 12 at 11:52
5
\$\begingroup\$

Bash, 22 19 bytes

-3 bytes thanks to @user41805

rs 0 1|sort|uniq -u

Try it online!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ rs 0 1 is shorter than tr \$\endgroup\$ – user41805 Apr 13 at 7:53
3
\$\begingroup\$

05AB1E, 5 bytes

«¹²ÃK

Try it online!

How?

«     - merge the two input lists   -> a+b
 ¹    - push 1st input list            a,a+b
  ²   - push 2nd input list            b,a,a+b
   Ã  - intersection                   b&a,a+b
    K - discard                        (a+b)-(b&a)
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

C (gcc), 98 96 bytes

*d;f(a,b,c)int*a,*b,*c;{for(;*c=*a++;c+=!(*d=-*d))for(d=b;*d&&*d-*c;d++);for(;*c=*b++;c+=*c>0);}

Try it online!

-2 bytes thanks to @ceilingcat

Input is in two 0-terminated arrays a and b, output as a 0-terminated array into preallocated buffer c.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Looks like it would be break-even to use a standard f(int*a,int*b,int*c){ instead of K&R. The repeated a,*b,*c; part is 8 bytes, same as 2x int*. No saving but nicer to read :/ \$\endgroup\$ – Peter Cordes Apr 14 at 2:19
2
\$\begingroup\$

Wolfram Language (Mathematica), 35 bytes

Join@##~Complement~Intersection@##&

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Red, 25 bytes

func[a b][difference a b]

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Sounds like difference (10 bytes) should be a valid solution...? \$\endgroup\$ – Bubbler Apr 12 at 11:29
  • 1
    \$\begingroup\$ @Bubbler I don't know - it would be just a word - neither a program nor a function. \$\endgroup\$ – Galen Ivanov Apr 12 at 11:54
  • 2
    \$\begingroup\$ @Bubbler Something like this? \$\endgroup\$ – Galen Ivanov Apr 12 at 11:57
  • 3
    \$\begingroup\$ Yeah. I think it is valid under CGCC rule because the word itself is reusable (even if you can't easily assign it to a different name). \$\endgroup\$ – Bubbler Apr 12 at 12:30
2
\$\begingroup\$

05AB1E, 6 bytes

«©ʒ®s¢

How does it work?

« merge lists
 © store in the global register
  ʒ keep only items which
   ®s¢ the number of times which they appear in the merged list is truthy, which is only 1 in 05AB1E

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Charcoal, 8 bytes

I⁺⁻θη⁻ηθ

Try it online! Link is to verbose version of code. Explanation:

   θ        First input
    η       Second input
  ⁻         Remove matching elements
      η     Second input
       θ    First input
     ⁻      Remove matching elements
 ⁺          Concatenate
I           Cast to string
            Implicitly print
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

JavaScript (ES6), 46 bytes

Takes input as (a)(b), where \$a\$ and \$b\$ are Sets. Returns a list.

JS has very few set built-ins, so this a bit verbose.

a=>b=>[...a,...b].filter(x=>a.has(x)^b.has(x))

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

MATL, 2 bytes

X~

Try it online!

Explanation

Built-in. Implicit inputs, implicit output.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Ruby, 16 14 bytes

->a,b{a-b|b-a}

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Julia, 7 bytes

symdiff

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

05AB1E, 4 bytes

«Ð¢Ï

Try it online.

Explanation:

      #  i.e. inputs: [1,2,3] and [2,3,4]
«     # Merge the two (implicit) input-lists together
      #  STACK: [[2,3,4,1,2,3]]
 Ð    # Triplicate this merged list
      #  STACK: [[2,3,4,1,2,3],[2,3,4,1,2,3],[2,3,4,1,2,3]]
  ¢   # Count all occurrences of the values in the list
      #  STACK: [[2,3,4,1,2,3],[2,2,1,1,2,2]]
   Ï  # Only leave the values at the truthy (count = 1) indices
      #  STACK: [[4,1]]
      # (after which the result is output implicitly)
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

R, 45 39 bytes

function(x,y,`-`=setdiff)union(x-y,y-x)

Try it online!

Thanks to user Kirill L.'s comment.

The original was the following.

function(x,y){s=setdiff;union(s(x,y),s(y,x))}

Try it online!

Straightforward, definition coded in R.

Note: the following function is also 45 bytes. I thought that to define s=setdiff first would save a few bytes but as it turns out the function will need a semi-colon instruction separator and to be between braces. For the same byte count a no-tricks function is more natural.

function(x,y)union(setdiff(x,y),setdiff(y,x))
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ You can still avoid those braces by aliasing setdiff inside function definition. And in this particular case you can save even more bytes, by aliasing it not as a variable, but as an operator! Try it online! \$\endgroup\$ – Kirill L. Apr 26 at 17:47
1
\$\begingroup\$

Icon, 38 bytes

procedure f(a,b)
return a++b--a**b
end

Try it online!

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Groovy, 18 bytes

f={a,b->a-b+(b-a)}

Try it online!

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

PowerShell, 39 bytes

param($a,$b)$a+$b|group|? c* -eq 1|% n*

Try it online!

unrolled:

param($a,$b)
$a+$b|group|where count -eq 1|% name
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Pyth, 5 bytes

-sQ@F

Try it online!

 sQ   sum inputs (union since inputs are sets)
-     minus
   @F intersection of inputs
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Perl 5, 42 bytes

sub u{map$k{$_}++,@_;grep$k{$_}==1,keys%k}

Try it online!

| improve this answer | |
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy