Set: Difference between revisions

{{trans|Python}}

 

V s2 = Set([3, 4, 5, 6])

print(s1.union(s2))

print(s1)

s1.discard(99)

 

{{out}}

The user must type in the monitor the following command after compilation and before running the program!<pre>SET EndProg=*</pre>

{{libheader|Action! Tool Kit}}

 

INCLUDE "D2:ALLOCATE.ACT" ;from the Action! Tool Kit. You must type 'SET EndProg=*' from the monitor after compiling, but before running this program!

Clear(s3)

Clear(s4)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Set.png Screenshot from Atari 8-bit computer]

An alternative hash-based solution could use the Hashed_Maps package from Ada.Containers.

 

use ada.text_io;

 

end loop;

end set_demo;

 

{{out}}

 

=={{header|Aime}}==

union(record a, record b)

{

 

return 0;

{{out}}

<pre> banana is not an element of A

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Reuses a lot of code from the Symetric difference task.

# include the associative array code for string keys and values #

PR read "aArray.a68" PR

print( ( "... after restoration of Pluto: " ) );

all planets // "Pluto";

{{out}}

<pre>

In Apex, Sets are unordered collections of elements. Although elements can be anything including primitives, Ids, Apex classes, or sObjects, typically they are used with primitives and Ids.

 

public class MySetController{

public Set<String> strSet {get; private set; }

}

}

</pre>

 

macOS's Foundation framework offers a few classes of set which can be used in AppleScript by means of AppleScriptObjectiveC code. The basic types are <tt>NSSet</tt> and its mutable equivalent <tt>NSMutableSet</tt>.

 

use framework "Foundation"

--use scripting additions

end doSetTask

 

 

{{out}}

 

\"aardvark\" is a member of S: false

3 is a member of S: true

A is a subset of S: true

A is equal to B: false

 

=={{header|Arturo}}==

b: [3 4 5 6]

 

print superset?.proper a [1 3]

print superset? [1 3] [1 3]

 

{{out}}

 

You might notice the operator overloading.

 

#define ATS_DYNLOADFLAG 0

println! ("set2 = set1: ", set2 = set1);

println! ("(set1 ^ set2) = (set2 ^ set1): ",

end

 

 

{{out}}

set1 = set2: false

set2 = set1: false

 

=={{header|AutoHotkey}}==

for i, val in Set

if (val=element)

equal(SetA,SetB){

return (SetA.MaxIndex() = SetB.MaxIndex() && subset(SetA,SetB)) ? 1: 0

B:= ["banana", "cherry", "date", "elderberry", "fig"]

C:= ["apple", "cherry", "elderberry", "grape", "orange"]

Res .= "`nA is " (equal(A,E)?"":"not ") "a equal to Set E"

 

{{out}}

<pre>A:= ["apple", "cherry", "elderberry", "grape"]

A is not a equal to Set E</pre>

 

The sets are represented as 32-bit integers, which means that the maximum number of elements is 32.

list$() = "apple", "banana", "cherry", "date", "elderberry", "fig", "grape"

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

NEXT

{{out}}

<pre>

BQN can use lists with only unique elements to represent sets. The following implement all the basic set relations.

 

Inter ← ∊/⊣

Diff ← ¬∘∊/⊣

•Show 2‿4‿6‿8 Subset 2‿3‿5‿7

•Show 2‿4‿6‿8 Eq 2‿3‿5‿7

⟨ 2 ⟩

⟨ 4 6 8 ⟩

0

0

 

=={{header|C}}==

 

A frequent use of set is that of small, non-negative integers, implemented as a bit field as shown below.

 

typedef unsigned int set_t; /* probably 32 bits; change according to need */

 

return 0;

 

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

using System.Collections.Generic;

using System.Linq;

Console.ReadKey();

}

{{out}}

<pre>Set creation

C++11 standard library also contains unordered_set based on a hash table. However, algorithms like std::set_intersection etc take sorted ranges, so set-specific functions should be hand-rolled.

 

#include <set>

#include <iostream>

return 0;

}

 

=={{header|Ceylon}}==

value a = set {1, 2, 3};

value b = set {3, 4, 5};

a subset of b? ``subset``

a == b? ``equality``");

 

=={{header|Clojure}}==

 

 

; sets can be created using the set method or set literal syntax

(clojure.set/difference a b)

 

 

=={{header|CoffeeScript}}==

This implements functions from the task, along with an iteration helper called "each".

# For ad-hoc set features, it sometimes makes sense to use hashes directly,

# rather than abstract to this level, but I'm showing a somewhat heavy

 

run_tests()

 

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

Common Lisp provides some set operations on lists.

(setf b '(2 3 4 5))

 

(subsetp b a))

"~a = ~a~%"

 

=={{header|D}}==

import std.stdio, std.algorithm, std.range;

 

const s5 = [1, 1, 1, 4, 4, 7, 7, 7, 7, 8, 8];

assert(s4.nWayUnion.equal(s5));

module set;

import std.typecons : Tuple, tuple;

return true;

}

 

=={{header|Dart}}==

//Set Creation

Set A = new Set.from([1,2,3]);

print('A is equal to B = ${B.containsAll(A) && A.containsAll(B)}');

print('B is equal to AC = ${B.containsAll(AC) && AC.containsAll(B)}');

{{out}}

<pre>Set A = {1, 2, 3}

{{libheader| Boost.Generics.Collection}}

The library [https://github.com/MaiconSoft/DelphiBoostLib Boost.Generics.Collection].

program Set_task;

 

Writeln('S1 equality S2? ', s1 = s2);

readln;

{{out}}

<pre>S1 { 1, 2, 3, 4, 5, 6 }

S3 is subset S2 TRUE

S1 equality S2? FALSE</pre>

 

=={{header|EchoLisp}}==

 

The set operations are: ∩ ∪ ⊆ / ∈ = ∆ ×

; use { } to read a set

(define A { 1 2 3 4 3 5 5}) → { 1 2 3 4 5 } ; duplicates are removed from a set

; A few functions return sets :

(primes 10) → { 2 3 5 7 11 13 17 19 23 29 }

 

=={{header|Elixir}}==

{{works with|Elixir|1.1}}

#MapSet<[]>

iex(2)> sa = MapSet.put(s, :a)

false

iex(14)> sa == sab

 

=={{header|Erlang}}==

=={{header|F_Sharp|F#}}==

The Collections.Set<'T> class implements "Immutable sets based on binary trees, where comparison is the F# structural comparison function, potentially using implementations of the IComparable interface on key values." (http://msdn.microsoft.com/en-us/library/ee353619.aspx)

let main args =

// Create some sets (of int):

printfn "s1 ⊂ s1? %A" (Set.isProperSubset s1 s1)

printfn "s1 ⊂ s2? %A" (Set.isProperSubset s1 s2)

{{out}}

<pre>Some sets (of int):

=={{header|Factor}}==

We will use Factor's hash-sets for this task. A hash-set is created with <code>HS{ ... }</code>.

( scratchpad ) HS{ 2 5 4 3 } HS{ 5 6 7 } union .

HS{ 2 3 4 5 6 7 }

f

( scratchpad ) HS{ 6 5 7 } HS{ 5 6 7 } set= .

 

=={{header|Forth}}==

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

 

i{ 5 6 } i{ 5 6 7 } set= . 0 ok

i{ 6 5 7 } i{ 5 6 7 } set= . -1 ok

 

=={{header|FreeBASIC}}==

'test if the value N is in the set S

for i as integer = 0 to ubound(S)

print "S2 = S3? ", is_equal(S2(), S3())

print "S4 proper subset of S3? ", is_proper_subset( S4(), S3() )

{{out}}

<pre>

 

=={{header|Frink}}==

a = new set[1, 2]

b = toSet[[2,3]] // Construct a set from an array

isSubset[a,b] // Returns true if a is a subset of b

a==b // set equality test

 

=={{header|FunL}}==

B = {3, 4, 5}

C = {1, 2, 3, 4, 5}

println( 'S subset of C: ' + S.subsetOf(C) )

S.remove( 1 )

 

{{out}}

S subset of C: true

S after 1 removed: {2, 3, 4}

</pre>

 

===Maps===

Go maps meet the task description in that they do not require orderable elements. To demonstrate that, a set of complex numbers is shown here. Complex numbers can be compared for equality but are not ordered.

 

import "fmt"

func properSubset(a, b set) bool {

return len(a) < len(b) && subset(a, b)

{{out}}

<pre>

 

Note that the elements here, being integers, are of course ordered and so might not meet a strict reading of the task requirements.

 

import (

}

return

{{out}}

<pre>

===Intsets===

Not quite in the stanard library but still in the official "sub repository", intsets are a ''sparse'' bit set. Like big.Int they use a single bit to represent a possible element, but the sparse representation efficiently allows for large "holes" in the element sequence. Also the intsets API provides a more set-like terminology so the RC task can be coded more directly.

 

import (

}

return &set

{{out}}

<pre>

 

=={{header|Groovy}}==

def m1 = 6

def m2 = 7

assert s1 != su && su.containsAll(s1) : 'proper subset'

s1 << 0

 

=={{header|Haskell}}==

{{works with|GHC}}

GHC offers a functional, persistent set data structure in its <code>Data.Set</code> module. It is implemented using a binary search tree. Elements must be of an orderable type (instance of <code>Ord</code>).

Prelude Data.Set> empty :: Set Integer -- Empty set

fromList []

fromList [1,2,3,4,99]

Prelude Data.Set> delete 3 s1 -- Create a new set by deleting

 

Regular lists can also be used as sets. Haskell has some functions to help with using lists as sets. No requirement is made of element type. However, these are not very efficient because they require linear time to find an element.

Prelude Data.List> let s3 = nub [1,2,3,4,3] -- Remove duplicates from list

Prelude Data.List> s3

[42,1,2,3,4]

Prelude Data.List> delete 3 s3 -- Return new list with first occurrence of element removed

 

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

Implemented directly:

 

procedure display_set (s)

writes ("[")

write ("(1,2,5) is not included in a")

end

 

{{out}}

Using library:

 

link sets

 

write ("(1,2,5) is not included in a")

end

 

{{out}}

Here are definitions for the required operations:

 

intersection=: [ -. -.

difference=: -.

subset=: *./@e.

 

Examples:

 

2 4 6 8 3 5 7

2 4 6 8 ([ -. -.) 2 3 5 7

1

2 4 6 8 3 5 7 -:&(/:~) 8 7 6 5 4 3 2

 

Examples again, using names rather than code:

 

2 4 6 8 3 5 7

2 4 6 8 intersection 2 3 5 7

1

2 4 6 8 3 5 7 equality 8 7 6 5 4 3 2

 

Note that J uses 1 for true and 0 for false. Mathematical revisionists object to this, but this is consistent with the original (and revised) formulations of boolean algebra. (And there are deep ties to Bayes' rule.)

Note that these operations can be combined in sentences with other operations. For example we could define

 

 

=={{header|Java}}==

{{works with|Java|7+}}

To use this in Java 5 replace all "<>" with "<Integer>".

import java.util.Collections;

import java.util.Set;

Collections.unmodifiableSet(a); //returns an immutable copy of a

}

{{out}}

<pre>a: [1, 2, 3, 4, 5]

JavaScript does not support native sets before ECMAScript 6.

 

var set = new Set();

 

for (var item of set) {

console.log('item is ' + item);

 

=={{header|jq}}==

 

For example:

 

Thus, it can be seen that jq has built-in support for sets of finite-length Unicode strings.

 

Here is a jq filter for determining whether a JSON object is a "string set":

 

'''String-set membership''':

The test for set membership, m ∈ S, where m is a string and S is a

set of strings, corresponds exactly to the jq test:

where T is the JSON object corresponding to S. This test is also efficient.

 

'''String-set intersection'''

def stringset_intersection(A;B):

reduce (A|keys)[] as $k

 

'''String-set difference'''

def stringset_difference(A;B):

reduce (A|keys)[] as $k

 

'''Subset'''

def stringset_subset(A;B):

reduce (A|keys)[] as $k

 

=== Finite Sets of JSON Entities ===

jq operator "unique". To test whether an arbitrary JSON entity is a set

without sorting:

. as $in

| type == "array" and

reduce range(0;length-1) as $i

 

The following library of set-theoretic functions is intended for use

whether m is an element of S, but for large sets, this is inefficient. A generally more efficient test membership of m in S would use

bsearch as defined at [[Binary search]] or as provided in recent versions of jq:

 

'''Intersection'''

def intersection($A;$B):

def pop:

else [$i, $j+1] | pop

end;

'''Difference'''

def difference(A;B):

(A|length) as $al

end

) | .[2]

 

'''Union'''

 

To compute the union of two sets efficiently, it is helpful to define a function for merging sorted arrays.

# if both arrays are sorted, the result will be sorted:

def merge(x):

def union(A;B):

A|merge(B)

 

'''A ⊆ B'''

# TCO

def _subset:

else [ .[0], .[1][1:] ] | _subset

end;

 

'''Test whether two sets intersect'''

If A and B are sets (i.e. A == (A|unique) and B == (B|unique)),

then ''[A,B] | intersect'' emits true if A and B have at least one element in common:

.[0] as $A | .[1] as $B

| ($A|length) as $al

end

end;

 

=={{header|Julia}}==

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

println("fruits5 + 'guava' : $fruits5")

println("fruits5 - 'cherry' : ${fruits5 - "cherry"}")

 

{{out}}

 

=={{header|Lasso}}==

define set->issubsetof(p::set) => .intersection(#p)->size == .size

define set->oncompare(p::set) => .intersection(#p)->size - .size

 

//A = B -- equality; true if every element of set A is in set B and vice-versa.

 

{{out}}

{{trans|Erlang}}

 

> (set set-1 (sets:new))

#(set 0 16 16 8 80 48 ...)

> (=:= set-3 set-4)

true

 

=={{header|Liberty BASIC}}==

Sets are not natively available- implemented here in string form so no need to dim/redim or pass number of elements.

A$ ="red hot chili peppers rule OK"

B$ ="lady in red"

end function

=={{header|Lua}}==

{{works with|lua|5.1}}

function insert(set, item) set[item] = true end

function remove(set, item) set[item] = nil end

return subset(setA, setB) and (size(setA) == size(setB))

end

 

{{works with|lua|5.3}}

The code is intended to be placed into a file and accessed as a module. E.g. if placed into the file "set.lua" it would be accessed with <code>set = require 'set'</code>.

 

local r = {}

local s = setmetatable({}, {

end

 

 

=={{header|M2000 Interpreter}}==

For search in a tuple we have O(N).

 

Module Sets {

setA=("apple", "cherry", "grape")

}

Sets

 

=={{header|Maple}}==

Sets in Maple are built-in, native data structures, and are immutable. Sets are formed by enclosing a sequence of objects between braces. You can get something essentially equivalent to set comprehensions by using {seq}, which applies the set constructor ("{}") to the sequencing operation "seq".

> S := { 2, 3, 5, 7, 11, Pi, "foo", { 2/3, 3/4, 4/5 } };

S := {2, 3, 5, 7, 11, "foo", Pi, {2/3, 3/4, 4/5}}

> evalb( { 1, 2, 3 } = { 1, 2, 4 } );

false

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

MemberQ[set1, "a"]

Union[set1 , set2]

MemberQ[Subsets[set2], set1](*Subset*)

set1 == set2(*Equality*)

{{out}}

<pre>True

 

There are two types of sets supported, sets with numeric values are stored in a vector, sets with string elements are stored in a cell-array.

% Set creation

s = [1, 2, 4]; % numeric values

% A = B -- equality; true if every element of set A is in set B and vice-versa.

isempty(setxor(A, B))

 

=={{header|Maxima}}==

 

a: {1, 2, 3, 4};

 

setequalp(a, b);

 

=={{header|Nanoquery}}==

This is a full implementation of a set class.

declare internal_list

 

return str(this.internal_list)

end

Testing this implementation:

 

a = new(set, {1, 2, 3, 4, 5})

println "a intersect b: " + a.intersection(b)

println "add 7 to a: " + a.append(7)

{{out}}

<pre>a: [1, 2, 3, 4, 5]

=={{header|Nemerle}}==

The <tt>Nemerle.Collections</tt> namespace provides an implementation of a Set.

using Nemerle.Collections;

 

WriteLine($"$same\t$sub12");

}

 

=={{header|Nim}}==

Here is an example of usage of a set.

 

s = {0, 3, 5, 10}

t = {3..20, 50..55}

 

s.incl(4) # add 4 to set

 

HashSets are not very different, less efficient but more versatile. Here is the same program with HashSets. The only difference is the way to create a HashSet: this is done by converting an array or sequence to the HashSet. As there is no way to specify a range in an array, we use a conversion of range to sequence with “toSeq” and a union.

 

 

var # creation

 

s.incl(4) # add 4 to set

 

Note that there exists also an Ordered constructor which remembers the insertion order. And for sets of integers, the module “intsets” provides another constructor better suited for sparse integer sets.

 

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

 

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

}

return 0;

{{out}}

<pre>

In the interactive toplevel:

{{works with|OCaml|4.02+}}

module IntSet :

sig

- : IntSet.elt list = [1; 2; 3; 4; 99]

# IntSet.elements (IntSet.remove 3 s1);; (* Create a new set by deleting *)

 

(Note: <code>of_list</code> is only available in OCaml 4.02+. In earlier versions, you can implement one yourself like

 

=={{header|Ol}}==

; test set

(define set1 '(1 2 3 4 5 6 7 8 9))

(print (equal? set1 set4))

; ==> #true

 

=={{header|ooRexx}}==

-- Using the OF method

s1 = .set~of(1, 2, 3, 4, 5, 6)

Use Arg set_name,set

Say set_name':' set~makearray~makestring((LINE),',')

The set operators don't come out too well :-(

{{out}}

=={{header|PARI/GP}}==

Aside from ⊆, all operations are already a part of GP.

for(i=1,#s,

if(!setsearch(t,s[i]), return(0))

setminus(s,t)

setsubset(s,t)

 

{{out}}

--[[User:Guionardo|Guionardo]] 22:03, 7 January 2012 (UTC)

 

 

{$mode objfpc}{$H+}

readln;

 

 

=={{header|Perl}}==

For real code, try Set::Object from CPAN. Here we provide a primitive implementation using hashes.

 

package Set; # likely will conflict with stuff on CPAN

print "w = x ^ y = ", $w = ($x ^ $y), "\n";

print "w is ", ($w == $z) ? "" : "not ", "equal to z\n";

 

=={{header|Phix}}==

First, a simple implementaion using native sequences:

{{out}}

<pre>

1

Alternative using dictionaries, which needs several additional visitor routines (at a pinch they could be merged),

but performance is better on larger sets:

 

 

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

We may use plain lists, or '[http://software-lab.de/doc/refI.html#idx idx]' structures for sets. A set may contain any type of data.

===Using lists===

Set1 (1 2 3 7 abc "def" (u v w))

Set2 (2 3 5 hello (x y z))

 

: (= (sort (copy Set2)) (sort (copy Set2)))

===Using 'idx' structures===

(balance 'Set1 (1 2 3 7 abc "def" (u v w)))

(balance 'Set2 (2 3 5 hello (x y z)))

 

: (= (idx 'Set2) (idx 'Set2))

 

=={{header|PowerShell}}==

When used in PowerShell, the syntax is clumsy. In addition, the "reference" set (<code>$set1</code>) is modified in place to become the result.

(All examples assume the variable <code>$set1</code> contains the value <code>@(1,2,3,4)</code>)

[System.Collections.Generic.HashSet[object]]$set1 = 1..4

[System.Collections.Generic.HashSet[object]]$set2 = 3..6

5 -in $set1 # Test membership False

7 -notin $set1 # Test non-membership True

 

=={{header|Prolog}}==

Works with SWI-Prolog, library(lists).

 

set :-

select(H1, B, B1),

equal(T1, B1).

{{out}}

<pre> ?- set.

It treats sets as ordered lists of unique elements:

 

%% Set creation

 

?- ord_del_element($NewA, 3, NewerA).

NewerA = [1, 2, 4, 19].

 

=={{header|PureBasic}}==

This solution uses PureBasic's maps (hash tables).

If b: ProcedureReturn "True": EndIf

ProcedureReturn "False"

Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre>Set A = (blue green orange red yellow) of cardinality 5.

(For versions prior to 2.7, use <code>set([1, 2, 3, 4])</code> instead of <code>{1, 2, 3, 4}</code>. Even in Python 2.7+ and 3.0+, it is necessary to write <code>set()</code> to express the empty set.)

{{works with|Python|2.7+ and 3.0+}}

>>> s1 | s2 # Union

{1, 2, 3, 4, 5, 6}

>>> s1

{1, 2, 3, 4, 5, 6}

 

=={{header|Quackery}}==

===Sorted Nests of Strings===

 

sort$ witheach

[ tuck != if

set{ orange }set dup echoset say " is"

fruits propersubset dup if [ say " not" ] say " the only fruit"

 

{{out}}

===Indexed Bitmaps===

 

[ elements share 2dup find

set{ orange }set dup echoset say " is"

fruits propersubset dup if [ say " not" ] say " the only fruit"

 

{{out}}

=={{header|Racket}}==

 

#lang racket

 

(subset? C A) ; gives #f

(subset? C B) ; gives #t

 

=={{header|Raku}}==

(formerly Perl 6)

 

my $a = set <a b c>;

nok $a ⊂ $a, "strict subset; false for equal sets";

ok $a === set(<a b c>), "equality; true if every element of set A is in set B and vice-versa";

{{out}}

<pre>ok 1 - c is an element in set A

=={{header|REXX}}==

REXX doesn't have native set support, but can be easily coded to handle lists as sets.

truth.0= 'false'; truth.1= "true" /*two common names for a truth table. */

set.= /*the order of sets isn't important. */

if eq then if arg()>3 then return 1

else return set$('equal', _2, _1, 1)

'''output'''

<pre>

 

=={{header|Ring}}==

# Project : Set

 

next

return flag

Output:

<pre>

Set A is not a subset of set B

Set A is not equal to set B

</pre>

 

=={{header|Ruby}}==

Ruby's standard library contains a "set" package, which provides <code>Set</code> and <code>SortedSet</code> classes.

=> true

>> s1, s2 = Set[1, 2, 3, 4], [3, 4, 5, 6].to_set # different ways of creating a set

>> s1.subtract(s2) # Mutability

=> #<Set: {1, 2}>

 

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

A$ = "apple cherry elderberry grape"

B$ = "banana cherry date elderberry fig"

print left$(sets$,1);" is not equal ";right$(sets$,1)

end if

<pre>A = apple cherry elderberry grape

B = banana cherry date elderberry fig

=={{header|Rust}}==

 

 

fn main() {

println!("Is A a subset of B? {}", a.is_subset(&b));

println!("Is A equal to B? {}", a == b);

 

=={{header|Scala}}==

object sets {

val set1 = Set(1,2,3,4,5)

println(set1 == set2)

}

 

=={{header|Scheme}}==

Implemented based on lists. Not efficient on large sets.

(and (not (null? lst))

(or (eq? a (car lst))

(define (set-eq? a b)

(and (subset? a b)

 

=={{header|Seed7}}==

 

const type: charSet is set of char;

writeln("A < A -- proper subset: " <& A < A);

writeln("A = B -- equality: " <& A = B);

 

{{out}}

 

=={{header|SETL}}==

A := {1, 2, 3, 4};

B := {3, 4, 5, 6};

print(C subset B); -- #T

print(C = B); -- #F

 

=={{header|Sidef}}==

{{trans|Perl}}

 

method init {

set.has(self)

}

 

Usage example:

5..7 -> each { |i| x += i }

 

say ("w = x ^ y = ", w = (x ^ y))

say ("w is ", w ≡ z ? "" : "not ", "equal to z")

{{out}}

<pre>

 

=={{header|Simula}}==

BEGIN

 

 

END.

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|Pharo|1.3-13315}}

#(1 2 3) asSet union: #(2 3 4) asSet.

"a Set(1 2 3 4)"

#(1 2 3) asSet = #(1 2 4) asSet.

"false"

 

=={{header|SQL}}==

{{works with|Oracle}}

-- set of numbers is a table

-- create one set with 3 elements

minus

select element from myset2));

 

<pre>

=={{header|Swift}}==

{{works with|Swift|1.2+}}

let s2 : Set<Int> = [3, 4, 5, 6]

println(s1.union(s2)) // union; prints "[5, 6, 2, 3, 1, 4]"

println(s1) // prints "[2, 1]"

s1.exclusiveOrInPlace(s2) // mutability

 

=={{header|Tcl}}==

Sets in Tcl are modeled as lists of items, with operations that preserve uniqueness of membership.

{{tcllib|struct::set}}

 

# Many ways to build sets

struct::set exclude s3 $item

# Getting the cardinality:

 

=={{header|VBA}}==

'A collection can hold any object as item. The examples here are only strings.

'A collection stores item, key pairs. With the key you can retrieve the item.

'Add "10" to A

A.Add "10", "10"

 

=={{header|Wren}}==

{{libheader|Wren-set}}

Note that the Set class in the above module uses a Map internally for storage. Consequently, iteration order is undefined.

 

var fruits = Set.new(["apple", "pear", "orange", "banana"])

System.print("fruits5 + 'guava' : %(fruits5)")

fruits5.remove("cherry")

 

{{out}}

fruits5 + 'guava' : <raspberry, guava, blueberry, cherry>

fruits5 - 'cherry' : <raspberry, guava, blueberry>

</pre>

 

=={{header|zkl}}==

A simplistic implementation that is fine for smallish sets

class Set {

fcn init { var [const] set = (vm.arglist.copy() : unique(_)) }

}

fcn __opEQ(setB) { ((set.len() == setB.set.len()) and self.isSubset(setB)) }

<pre>

A := Set(1,2,3,3,3,4);