tasks a-s
This commit is contained in:
Ingy döt Net
parent
47bf37c096
commit
b83f433714
12433 changed files with 156208 additions and 123 deletions
16
Task/Set/0DESCRIPTION
Normal file
16
Task/Set/0DESCRIPTION
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
{{data structure}}
|
||||
A set is a collection of elements, without duplicates and without order.
|
||||
|
||||
Show each of these set operations:
|
||||
|
||||
* Set creation
|
||||
* Test m ∈ S -- "m is an element in set S"
|
||||
* A ∪ B -- ''union''; a set of all elements either in set A or in set B.
|
||||
* A ∩ B -- ''intersection''; a set of all elements in ''both'' set A and set B.
|
||||
* A ∖ B -- ''difference''; a set of all elements in set A, except those in set B.
|
||||
* A ⊆ B -- ''subset''; true if every element in set A is also in set B.
|
||||
* A = B -- ''equality''; true if every element of set A is in set B and vice-versa.
|
||||
|
||||
As an option, show some other set operations. (If A ⊆ B, but A ≠ B, then A is called a true or proper subset of B, written A ⊂ B or A ⊊ B.) As another option, show how to modify a mutable set.
|
||||
|
||||
One might implement a set using an [[associative array]] (with set elements as array keys and some dummy value as the values). One might also implement a set with a binary search tree, or with a hash table, or with an ordered array of binary bits (operated on with bitwise binary operators). The basic test, m ∈ S, is [[O]](n) with a sequential list of elements, O(''log'' n) with a balanced binary search tree, or (O(1) average-case, O(n) worst case) with a hash table.
|
||||
2
Task/Set/1META.yaml
Normal file
2
Task/Set/1META.yaml
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
---
|
||||
note: Discrete math
|
||||
54
Task/Set/Ada/set.ada
Normal file
54
Task/Set/Ada/set.ada
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
with Ada.Text_IO, Ada.Containers.Ordered_Sets;
|
||||
|
||||
procedure Set_Demo is
|
||||
|
||||
package CS is new Ada.Containers.Ordered_Sets(Character); use CS;
|
||||
package IO renames Ada.Text_IO;
|
||||
|
||||
-- helper functions for string to something conversion, and vice versa
|
||||
function To_Set(S: String) return Set is
|
||||
Result: Set;
|
||||
begin
|
||||
for I in S'Range loop
|
||||
begin
|
||||
Result.Insert(S(I));
|
||||
-- raises Constraint_Error if S(I) is already in Result
|
||||
exception
|
||||
when Constraint_Error => null;
|
||||
end;
|
||||
end loop;
|
||||
return Result;
|
||||
end To_Set;
|
||||
|
||||
function Image(S: Set) return String is
|
||||
C: Character;
|
||||
T: Set := S;
|
||||
begin
|
||||
if T.Is_Empty then
|
||||
return "";
|
||||
else
|
||||
C:= T.First_Element;
|
||||
T.Delete_First;
|
||||
return C & Image(T);
|
||||
end if;
|
||||
end Image;
|
||||
|
||||
function Image(C: Ada.Containers.Count_Type) return String renames
|
||||
Ada.Containers.Count_Type'Image;
|
||||
|
||||
S1, S2: Set;
|
||||
begin -- main program
|
||||
loop
|
||||
S1 := To_Set(Ada.Text_IO.Get_Line);
|
||||
exit when S1 = To_Set("quit!");
|
||||
S2 := To_Set(Ada.Text_IO.Get_Line);
|
||||
IO.Put_Line("Sets [" & Image(S1) & "], [" & Image(S2) & "] of size"
|
||||
& Image(S1.Length) & " and" & Image(S2.Length) & ".");
|
||||
IO.Put_Line("Intersection: [" & Image(Intersection(S1, S2)) & "],");
|
||||
IO.Put_Line("Union: [" & Image(Union(S1, S2)) & "],");
|
||||
IO.Put_Line("Difference: [" & Image(Difference(S1, S2)) & "],");
|
||||
IO.Put_Line("Symmetric Diff: [" & Image(S1 xor S2) & "],");
|
||||
IO.Put_Line("Subset: " & Boolean'Image(S1.Is_Subset(S2))
|
||||
& ", Equal: " & Boolean'Image(S1 = S2) & ".");
|
||||
end loop;
|
||||
end Set_Demo;
|
||||
43
Task/Set/BBC-BASIC/set.bbc
Normal file
43
Task/Set/BBC-BASIC/set.bbc
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
DIM list$(6)
|
||||
list$() = "apple", "banana", "cherry", "date", "elderberry", "fig", "grape"
|
||||
|
||||
setA% = %1010101
|
||||
PRINT "Set A: " FNlistset(list$(), setA%)
|
||||
setB% = %0111110
|
||||
PRINT "Set B: " FNlistset(list$(), setB%)
|
||||
elementM% = %0000010
|
||||
PRINT "Element M: " FNlistset(list$(), elementM%) '
|
||||
|
||||
IF elementM% AND setA% THEN
|
||||
PRINT "M is an element of set A"
|
||||
ELSE
|
||||
PRINT "M is not an element of set A"
|
||||
ENDIF
|
||||
IF elementM% AND setB% THEN
|
||||
PRINT "M is an element of set B"
|
||||
ELSE
|
||||
PRINT "M is not an element of set B"
|
||||
ENDIF
|
||||
|
||||
PRINT '"The union of A and B is " FNlistset(list$(), setA% OR setB%)
|
||||
PRINT "The intersection of A and B is " FNlistset(list$(), setA% AND setB%)
|
||||
PRINT "The difference of A and B is " FNlistset(list$(), setA% AND NOT setB%)
|
||||
|
||||
IF (setA% AND setB%) = setA% THEN
|
||||
PRINT '"Set A is a subset of set B"
|
||||
ELSE
|
||||
PRINT '"Set A is not a subset of set B"
|
||||
ENDIF
|
||||
IF setA% = setB% THEN
|
||||
PRINT "Set A is equal to set B"
|
||||
ELSE
|
||||
PRINT "Set A is not equal to set B"
|
||||
ENDIF
|
||||
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$))
|
||||
79
Task/Set/C++/set.cpp
Normal file
79
Task/Set/C++/set.cpp
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
#include <set>
|
||||
#include <iostream>
|
||||
#include <iterator>
|
||||
#include <algorithm>
|
||||
|
||||
namespace set_display {
|
||||
template <class T>
|
||||
std::ostream& operator<<(std::ostream& os, const std::set<T>& set)
|
||||
{
|
||||
os << '[';
|
||||
if (!set.empty()) {
|
||||
std::copy(set.begin(), --set.end(), std::ostream_iterator<T>(os, ", "));
|
||||
os << *--set.end();
|
||||
}
|
||||
return os << ']';
|
||||
}
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool contains(const std::set<T>& set, const T& key)
|
||||
{
|
||||
return set.count(key) != 0;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
std::set<T> set_union(const std::set<T>& a, const std::set<T>& b)
|
||||
{
|
||||
std::set<T> result;
|
||||
std::set_union(a.begin(), a.end(), b.begin(), b.end(), std::inserter(result, result.end()));
|
||||
return result;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
std::set<T> set_intersection(const std::set<T>& a, const std::set<T>& b)
|
||||
{
|
||||
std::set<T> result;
|
||||
std::set_intersection(a.begin(), a.end(), b.begin(), b.end(), std::inserter(result, result.end()));
|
||||
return result;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
std::set<T> set_difference(const std::set<T>& a, const std::set<T>& b)
|
||||
{
|
||||
std::set<T> result;
|
||||
std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(result, result.end()));
|
||||
return result;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool is_subset(const std::set<T>& set, const std::set<T>& subset)
|
||||
{
|
||||
return std::includes(set.begin(), set.end(), subset.begin(), subset.end());
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
using namespace set_display;
|
||||
std::set<int> a{2, 5, 7, 5, 9, 2}; //C++11 initialization syntax
|
||||
std::set<int> b{1, 5, 9, 7, 4 };
|
||||
std::cout << "a = " << a << '\n';
|
||||
std::cout << "b = " << b << '\n';
|
||||
|
||||
int value1 = 8, value2 = 5;
|
||||
std::cout << "Set a " << (contains(a, value1) ? "contains " : "does not contain ") << value1 << '\n';
|
||||
std::cout << "Set a " << (contains(a, value2) ? "contains " : "does not contain ") << value2 << '\n';
|
||||
|
||||
std::cout << "Union of a and b: " << set_union(a, b) << '\n';
|
||||
std::cout << "Intersection of a and b: " << set_intersection(a, b) << '\n';
|
||||
std::cout << "Difference of a and b: " << set_difference(a, b) << '\n';
|
||||
|
||||
std::set<int> sub{5, 9};
|
||||
std::cout << "Set b " << (is_subset(a, b) ? "is" : "is not") << " a subset of a\n";
|
||||
std::cout << "Set " << sub << ' ' << (is_subset(a, sub) ? "is" : "is not") << " a subset of a\n";
|
||||
|
||||
std::set<int> copy = a;
|
||||
std::cout << "a " << (a == copy ? "equals " : "does not equal ") << copy << '\n';
|
||||
|
||||
return 0;
|
||||
}
|
||||
45
Task/Set/C/set.c
Normal file
45
Task/Set/C/set.c
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
#include <stdio.h>
|
||||
|
||||
typedef unsigned int set_t; /* probably 32 bits; change according to need */
|
||||
|
||||
void show_set(set_t x, const char *name)
|
||||
{
|
||||
int i;
|
||||
printf("%s is:", name);
|
||||
for (i = 0; (1U << i) <= x; i++)
|
||||
if (x & (1U << i))
|
||||
printf(" %d", i);
|
||||
putchar('\n');
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int i;
|
||||
set_t a, b, c;
|
||||
|
||||
a = 0; /* empty set */
|
||||
for (i = 0; i < 10; i += 3) /* add 0 3 6 9 to set a */
|
||||
a |= (1U << i);
|
||||
show_set(a, "a");
|
||||
|
||||
for (i = 0; i < 5; i++)
|
||||
printf("\t%d%s in set a\n", i, (a & (1U << i)) ? "":" not");
|
||||
|
||||
b = a;
|
||||
b |= (1U << 5); b |= (1U << 10); /* b is a plus 5, 10 */
|
||||
b &= ~(1U << 0); /* sans 0 */
|
||||
show_set(b, "b");
|
||||
|
||||
show_set(a | b, "union(a, b)");
|
||||
show_set(c = a & b, "c = common(a, b)");
|
||||
show_set(a & ~b, "a - b"); /* diff, not arithmetic minus */
|
||||
show_set(b & ~a, "b - a");
|
||||
printf("b is%s a subset of a\n", !(b & ~a) ? "" : " not");
|
||||
printf("c is%s a subset of a\n", !(c & ~a) ? "" : " not");
|
||||
|
||||
printf("union(a, b) - common(a, b) %s union(a - b, b - a)\n",
|
||||
((a | b) & ~(a & b)) == ((a & ~b) | (b & ~a))
|
||||
? "equals" : "does not equal");
|
||||
|
||||
return 0;
|
||||
}
|
||||
15
Task/Set/Clojure/set.clj
Normal file
15
Task/Set/Clojure/set.clj
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
(require 'clojure.set)
|
||||
|
||||
; sets can be created using the set method or set literal syntax
|
||||
(def a (set [1 2 3 4]))
|
||||
(def b #{4 5 6 7})
|
||||
|
||||
(a 10) ; returns the element if it's contained in the set, otherwise nil
|
||||
|
||||
(clojure.set/union a b)
|
||||
|
||||
(clojure.set/intersection a b)
|
||||
|
||||
(clojure.set/difference a b)
|
||||
|
||||
(clojure.set/subset? a b)
|
||||
85
Task/Set/CoffeeScript/set.coffeescript
Normal file
85
Task/Set/CoffeeScript/set.coffeescript
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
# 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
|
||||
# solution to show off CoffeeScript class syntax.
|
||||
class Set
|
||||
constructor: (elems...) ->
|
||||
@hash = {}
|
||||
for elem in elems
|
||||
@hash[elem] = true
|
||||
|
||||
add: (elem) ->
|
||||
@hash[elem] = true
|
||||
|
||||
remove: (elem) ->
|
||||
delete @hash[elem]
|
||||
|
||||
has: (elem) ->
|
||||
@hash[elem]?
|
||||
|
||||
union: (set2) ->
|
||||
set = new Set()
|
||||
for elem of @hash
|
||||
set.add elem
|
||||
for elem in set2.to_array()
|
||||
set.add elem
|
||||
set
|
||||
|
||||
intersection: (set2) ->
|
||||
set = new Set()
|
||||
for elem of @hash
|
||||
set.add elem if set2.has elem
|
||||
set
|
||||
|
||||
minus: (set2) ->
|
||||
set = new Set()
|
||||
for elem of @hash
|
||||
set.add elem if !set2.has elem
|
||||
set
|
||||
|
||||
is_subset_of: (set2) ->
|
||||
for elem of @hash
|
||||
return false if !set2.has elem
|
||||
true
|
||||
|
||||
equals: (set2) ->
|
||||
this.is_subset_of(set2) and set2.is_subset_of this
|
||||
|
||||
to_array: ->
|
||||
(elem for elem of @hash)
|
||||
|
||||
each: (f) ->
|
||||
for elem of @hash
|
||||
f(elem)
|
||||
|
||||
to_string: ->
|
||||
@to_array()
|
||||
|
||||
run_tests = ->
|
||||
set1 = new Set("apple", "banana") # creation
|
||||
console.log set1.has "apple" # true (membership)
|
||||
console.log set1.has "worms" # false (membership)
|
||||
|
||||
set2 = new Set("banana", "carrots")
|
||||
console.log set1.union(set2).to_string() # [ 'apple', 'banana', 'carrots' ] (union)
|
||||
console.log set1.intersection(set2).to_string() # [ 'banana' ] (intersection)
|
||||
console.log set1.minus(set2).to_string() # [ 'apple' ] (difference)
|
||||
|
||||
set3 = new Set("apple")
|
||||
console.log set3.is_subset_of set1 # true
|
||||
console.log set3.is_subset_of set2 # false
|
||||
|
||||
set4 = new Set("apple", "banana")
|
||||
console.log set4.equals set1 # true
|
||||
console.log set4.equals set2 # false
|
||||
|
||||
set5 = new Set("foo")
|
||||
set5.add "bar" # add
|
||||
console.log set5.to_string() # [ 'foo', 'bar' ]
|
||||
set5.remove "bar" # remove
|
||||
console.log set5.to_string() # [ 'foo' ]
|
||||
|
||||
# iteration, prints apple then banana (order not guaranteed)
|
||||
set1.each (elem) ->
|
||||
console.log elem
|
||||
|
||||
run_tests()
|
||||
22
Task/Set/Common-Lisp/set.lisp
Normal file
22
Task/Set/Common-Lisp/set.lisp
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
(setf a '(1 2 3 4))
|
||||
(setf b '(2 3 4 5))
|
||||
|
||||
(format t "sets: ~a ~a~%" a b)
|
||||
|
||||
;;; element
|
||||
(loop for x from 1 to 6 do
|
||||
(format t (if (member x a)
|
||||
"~d ∈ A~%"
|
||||
"~d ∉ A~%") x))
|
||||
|
||||
(format t "A ∪ B: ~a~%" (union a b))
|
||||
(format t "A ∩ B: ~a~%" (intersection a b))
|
||||
(format t "A \\ B: ~a~%" (set-difference a b))
|
||||
(format t (if (subsetp a b)
|
||||
"~a ⊆ ~a~%"
|
||||
"~a ⊈ ~a~%") a b)
|
||||
|
||||
(format t (if (and (subsetp a b)
|
||||
(subsetp b a))
|
||||
"~a = ~a~%"
|
||||
"~a ≠ ~a~%") a b)
|
||||
18
Task/Set/D/set.d
Normal file
18
Task/Set/D/set.d
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
import std.stdio, std.algorithm;
|
||||
|
||||
void main() {
|
||||
auto set1 = [1, 2, 3, 4, 5, 6];
|
||||
auto set2 = [2, 5, 6, 3, 4, 8].sort; // [2, 3, 4, 5, 6, 8]
|
||||
auto set3 = [1, 2, 5];
|
||||
|
||||
assert(equal(setUnion(set1, set2), [1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8]));
|
||||
assert(equal(setIntersection(set1, set2), [2, 3, 4, 5, 6]));
|
||||
assert(equal(setDifference(set1, set2), [1]));
|
||||
assert(equal(setSymmetricDifference(set1, set2), [1, 8]));
|
||||
assert(equal(setDifference(set3, set1), new int[](0))); // subset
|
||||
assert(set1 != set2);
|
||||
|
||||
auto set4 = [ [ 1, 4, 7, 8 ], [ 1, 7 ], [ 1, 7, 8], [ 4 ], [ 7 ], ];
|
||||
auto set5 = [ 1, 1, 1, 4, 4, 7, 7, 7, 7, 8, 8 ];
|
||||
assert(equal(nWayUnion(set4), set5));
|
||||
}
|
||||
15
Task/Set/Factor/set.factor
Normal file
15
Task/Set/Factor/set.factor
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
( scratchpad ) USE: sets
|
||||
( scratchpad ) HS{ 2 5 4 3 } HS{ 5 6 7 } union .
|
||||
HS{ 2 3 4 5 6 7 }
|
||||
( scratchpad ) HS{ 2 5 4 3 } HS{ 5 6 7 } intersect .
|
||||
HS{ 5 }
|
||||
( scratchpad ) HS{ 2 5 4 3 } HS{ 5 6 7 } diff .
|
||||
HS{ 2 3 4 }
|
||||
( scratchpad ) HS{ 2 5 4 3 } HS{ 5 6 7 } subset? .
|
||||
f
|
||||
( scratchpad ) HS{ 5 6 } HS{ 5 6 7 } subset? .
|
||||
t
|
||||
( scratchpad ) HS{ 5 6 } HS{ 5 6 7 } set= .
|
||||
f
|
||||
( scratchpad ) HS{ 6 5 7 } HS{ 5 6 7 } set= .
|
||||
t
|
||||
124
Task/Set/Go/set.go
Normal file
124
Task/Set/Go/set.go
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
type set map[int]bool
|
||||
|
||||
func main() {
|
||||
// task: set creation
|
||||
s0 := make(set) // create empty set
|
||||
s1 := set{3: true} // create set with one element
|
||||
s2 := set{3: true, 1: true} // create set with two elements
|
||||
|
||||
// option: another way to create a set
|
||||
s3 := newSet([]int{3, 1, 4, 1, 5, 9})
|
||||
|
||||
// option: output!
|
||||
fmt.Println("s0:", s0)
|
||||
fmt.Println("s1:", s1)
|
||||
fmt.Println("s2:", s2)
|
||||
fmt.Println("s3:", s3)
|
||||
|
||||
// task: element predicate
|
||||
fmt.Printf("%v ∈ s0: %t\n", 3, s0.hasElement(3))
|
||||
fmt.Printf("%v ∈ s3: %t\n", 3, s3.hasElement(3))
|
||||
fmt.Printf("%v ∈ s3: %t\n", 2, s3.hasElement(2))
|
||||
|
||||
// task: union
|
||||
b := set{4: true, 2: true}
|
||||
fmt.Printf("s3 ∪ %v: %v\n", b, union(s3, b))
|
||||
|
||||
// task: intersection
|
||||
fmt.Printf("s3 ∩ %v: %v\n", b, intersection(s3, b))
|
||||
|
||||
// task: difference
|
||||
fmt.Printf("s3 \\ %v: %v\n", b, difference(s3, b))
|
||||
|
||||
// task: subset predicate
|
||||
fmt.Printf("%v ⊆ s3: %t\n", b, subset(b, s3))
|
||||
fmt.Printf("%v ⊆ s3: %t\n", s2, subset(s2, s3))
|
||||
fmt.Printf("%v ⊆ s3: %t\n", s0, subset(s0, s3))
|
||||
|
||||
// task: equality
|
||||
s2Same := set{1: true, 3: true}
|
||||
fmt.Printf("%v = s2: %t\n", s2Same, equal(s2Same, s2))
|
||||
|
||||
// option: proper subset
|
||||
fmt.Printf("%v ⊂ s2: %t\n", s2Same, properSubset(s2Same, s2))
|
||||
fmt.Printf("%v ⊂ s3: %t\n", s2Same, properSubset(s2Same, s3))
|
||||
|
||||
// option: delete. it's built in.
|
||||
delete(s3, 3)
|
||||
fmt.Println("s3, 3 deleted:", s3)
|
||||
}
|
||||
|
||||
func newSet(ms []int) set {
|
||||
s := make(set)
|
||||
for _, m := range ms {
|
||||
s[m] = true
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func (s set) String() string {
|
||||
if len(s) == 0 {
|
||||
return "∅"
|
||||
}
|
||||
r := "{"
|
||||
for e := range s {
|
||||
r = fmt.Sprintf("%s%v, ", r, e)
|
||||
}
|
||||
return r[:len(r)-2] + "}"
|
||||
}
|
||||
|
||||
func (s set) hasElement(m int) bool {
|
||||
return s[m]
|
||||
}
|
||||
|
||||
func union(a, b set) set {
|
||||
s := make(set)
|
||||
for e := range a {
|
||||
s[e] = true
|
||||
}
|
||||
for e := range b {
|
||||
s[e] = true
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func intersection(a, b set) set {
|
||||
s := make(set)
|
||||
for e := range a {
|
||||
if b[e] {
|
||||
s[e] = true
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func difference(a, b set) set {
|
||||
s := make(set)
|
||||
for e := range a {
|
||||
if !b[e] {
|
||||
s[e] = true
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func subset(a, b set) bool {
|
||||
for e := range a {
|
||||
if !b[e] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func equal(a, b set) bool {
|
||||
return len(a) == len(b) && subset(a, b)
|
||||
}
|
||||
|
||||
func properSubset(a, b set) bool {
|
||||
return len(a) < len(b) && subset(a, b)
|
||||
}
|
||||
19
Task/Set/Groovy/set.groovy
Normal file
19
Task/Set/Groovy/set.groovy
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
def s1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] as Set
|
||||
def m1 = 6
|
||||
def m2 = 7
|
||||
def s2 = [0, 2, 4, 6, 8] as Set
|
||||
assert m1 in s1 : 'member'
|
||||
assert ! (m2 in s2) : 'not a member'
|
||||
def su = s1 + s2
|
||||
assert su == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] as Set : 'union'
|
||||
def si = s1.intersect(s2)
|
||||
assert si == [8, 6, 4, 2] as Set : 'intersection'
|
||||
def sd = s1 - s2
|
||||
assert sd == [1, 3, 5, 7, 9, 10] as Set : 'difference'
|
||||
assert s1.containsAll(si) : 'subset'
|
||||
assert ! s1.containsAll(s2) : 'not a subset'
|
||||
assert (si + sd) == s1 : 'equality'
|
||||
assert (s2 + sd) != s1 : 'inequality'
|
||||
assert s1 != su && su.containsAll(s1) : 'proper subset'
|
||||
s1 << 0
|
||||
assert s1 == su : 'added element 0 to s1'
|
||||
35
Task/Set/Haskell/set-1.hs
Normal file
35
Task/Set/Haskell/set-1.hs
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
Prelude> import Data.Set
|
||||
Prelude Data.Set> empty :: Set Integer -- Empty set
|
||||
fromList []
|
||||
Prelude Data.Set> let s1 = fromList [1,2,3,4,3] -- Convert list into set
|
||||
Prelude Data.Set> s1
|
||||
fromList [1,2,3,4]
|
||||
Prelude Data.Set> let s2 = fromList [3,4,5,6]
|
||||
Prelude Data.Set> union s1 s2 -- Union
|
||||
fromList [1,2,3,4,5,6]
|
||||
Prelude Data.Set> intersection s1 s2 -- Intersection
|
||||
fromList [3,4]
|
||||
Prelude Data.Set> s1 \\ s2 -- Difference
|
||||
fromList [1,2]
|
||||
Prelude Data.Set> s1 `isSubsetOf` s1 -- Subset
|
||||
True
|
||||
Prelude Data.Set> fromList [3,1] `isSubsetOf` s1
|
||||
True
|
||||
Prelude Data.Set> s1 `isProperSubsetOf` s1 -- Proper subset
|
||||
False
|
||||
Prelude Data.Set> fromList [3,1] `isProperSubsetOf` s1
|
||||
True
|
||||
Prelude Data.Set> fromList [3,2,4,1] == s1 -- Equality
|
||||
True
|
||||
Prelude Data.Set> s1 == s2
|
||||
False
|
||||
Prelude Data.Set> 2 `member` s1 -- Membership
|
||||
True
|
||||
Prelude Data.Set> 10 `notMember` s1
|
||||
True
|
||||
Prelude Data.Set> size s1 -- Cardinality
|
||||
4
|
||||
Prelude Data.Set> insert 99 s1 -- Create a new set by inserting
|
||||
fromList [1,2,3,4,99]
|
||||
Prelude Data.Set> delete 3 s1 -- Create a new set by deleting
|
||||
fromList [1,2,4]
|
||||
15
Task/Set/Haskell/set-2.hs
Normal file
15
Task/Set/Haskell/set-2.hs
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
Prelude> import Data.List
|
||||
Prelude Data.List> let s3 = nub [1,2,3,4,3] -- Remove duplicates from list
|
||||
Prelude Data.List> s3
|
||||
[1,2,3,4]
|
||||
Prelude Data.List> let s4 = [3,4,5,6]
|
||||
Prelude Data.List> union s3 s4 -- Union
|
||||
[1,2,3,4,5,6]
|
||||
Prelude Data.List> intersect s3 s4 -- Intersection
|
||||
[3,4]
|
||||
Prelude Data.List> s3 \\ s4 -- Difference
|
||||
[1,2]
|
||||
Prelude Data.List> 42 : s3 -- Return new list with element inserted at the beginning
|
||||
[42,1,2,3,4]
|
||||
Prelude Data.List> delete 3 s3 -- Return new list with first occurrence of element removed
|
||||
[1,2,4]
|
||||
61
Task/Set/Icon/set-1.icon
Normal file
61
Task/Set/Icon/set-1.icon
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
procedure display_set (s)
|
||||
writes ("[")
|
||||
every writes (!s || " ")
|
||||
write ("]")
|
||||
end
|
||||
|
||||
# fail unless s1 and s2 contain the same elements
|
||||
procedure set_equals (s1, s2)
|
||||
return subset(s1, s2) & subset(s2, s1)
|
||||
end
|
||||
|
||||
# fail if every element in s2 is not contained in s1
|
||||
procedure subset (s1, s2)
|
||||
every (a := !s2) do {
|
||||
if not(member(s1,a)) then fail
|
||||
}
|
||||
return s2
|
||||
end
|
||||
|
||||
procedure main ()
|
||||
a := set(1, 1, 2, 3, 4)
|
||||
b := set(2, 3, 5)
|
||||
writes ("a: ")
|
||||
display_set (a)
|
||||
writes ("b: ")
|
||||
display_set (b)
|
||||
# basic set operations
|
||||
writes ("Intersection: ")
|
||||
display_set (a ** b)
|
||||
writes ("Union: ")
|
||||
display_set (a ++ b)
|
||||
writes ("Difference: ")
|
||||
display_set (a -- b)
|
||||
# membership
|
||||
if member(a, 2) then
|
||||
write ("2 is a member of a")
|
||||
else
|
||||
write ("2 is not a member of a")
|
||||
if member(a, 5) then
|
||||
write ("5 is a member of a")
|
||||
else
|
||||
write ("5 is not a member of a")
|
||||
# equality
|
||||
if set_equals(a, set(1,2,3,4,4)) then
|
||||
write ("a equals set(1,2,3,4,4)")
|
||||
else
|
||||
write ("a does not equal set(1,2,3,4,4)")
|
||||
if set_equals(a, b) then
|
||||
write ("a equals b")
|
||||
else
|
||||
write ("a does not equal b")
|
||||
# subset
|
||||
if subset(a, set(1,2)) then
|
||||
write ("(1,2) is included in a")
|
||||
else
|
||||
write ("(1,2) is not included in a")
|
||||
if subset(a, set(1,2,5)) then
|
||||
write ("(1,2,5) is included in a")
|
||||
else
|
||||
write ("(1,2,5) is not included in a")
|
||||
end
|
||||
39
Task/Set/Icon/set-2.icon
Normal file
39
Task/Set/Icon/set-2.icon
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
link sets
|
||||
|
||||
procedure main ()
|
||||
a := set(1, 1, 2, 3, 4)
|
||||
b := set(2, 3, 5)
|
||||
write ("a: ", simage(a))
|
||||
write ("b: ", simage(b))
|
||||
# basic set operations
|
||||
write ("Intersection: ", simage (a**b))
|
||||
write ("Union: ", simage (a++b))
|
||||
write ("Difference: ", simage (a--b))
|
||||
# membership
|
||||
if member(a, 2) then
|
||||
write ("2 is a member of a")
|
||||
else
|
||||
write ("2 is not a member of a")
|
||||
if member(a, 5) then
|
||||
write ("5 is a member of a")
|
||||
else
|
||||
write ("5 is not a member of a")
|
||||
# equality
|
||||
if seteq(a, set(1,2,3,4,4)) then
|
||||
write ("a equals set(1,2,3,4,4)")
|
||||
else
|
||||
write ("a does not equal set(1,2,3,4,4)")
|
||||
if seteq(a, b) then
|
||||
write ("a equals b")
|
||||
else
|
||||
write ("a does not equal b")
|
||||
# check subset
|
||||
if setlt(set(1,2), a) then
|
||||
write ("(1,2) is included in a")
|
||||
else
|
||||
write ("(1,2) is not included in a")
|
||||
if setlt(a, set(1,2,5), a) then
|
||||
write ("(1,2,5) is included in a")
|
||||
else
|
||||
write ("(1,2,5) is not included in a")
|
||||
end
|
||||
5
Task/Set/J/set-1.j
Normal file
5
Task/Set/J/set-1.j
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
union=: ~.@,
|
||||
intersection=: [ -. -.
|
||||
difference=: -.
|
||||
subset=: *./@e.
|
||||
equality=: -:&(/:~)
|
||||
12
Task/Set/J/set-2.j
Normal file
12
Task/Set/J/set-2.j
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
2 4 6 8 ~.@, 2 3 5 7
|
||||
2 4 6 8 3 5 7
|
||||
2 4 6 8 ([ -. -.) 2 3 5 7
|
||||
2
|
||||
2 4 6 8 -. 2 3 5 7
|
||||
4 6 8
|
||||
2 4 6 8 *./@e. 2 3 5 7
|
||||
0
|
||||
'' *./@e. 2 3 5 7
|
||||
1
|
||||
2 4 6 8 3 5 7 -:&(/:~) 8 7 6 5 4 3 2
|
||||
1
|
||||
12
Task/Set/J/set-3.j
Normal file
12
Task/Set/J/set-3.j
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
2 4 6 8 union 2 3 5 7
|
||||
2 4 6 8 3 5 7
|
||||
2 4 6 8 intersection 2 3 5 7
|
||||
2
|
||||
2 4 6 8 difference 2 3 5 7
|
||||
4 6 8
|
||||
2 4 6 8 subset 2 3 5 7
|
||||
0
|
||||
'' subset 2 3 5 7
|
||||
1
|
||||
2 4 6 8 3 5 7 equality 8 7 6 5 4 3 2
|
||||
1
|
||||
1
Task/Set/J/set-4.j
Normal file
1
Task/Set/J/set-4.j
Normal file
|
|
@ -0,0 +1 @@
|
|||
properSubset=: subset *. 1 - equality
|
||||
62
Task/Set/Java/set.java
Normal file
62
Task/Set/Java/set.java
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.Set;
|
||||
import java.util.TreeSet;
|
||||
|
||||
public class Sets {
|
||||
public static void main(String[] args){
|
||||
Set<Integer> a = new TreeSet<>();
|
||||
//TreeSet sorts on natural ordering (or an optional comparator)
|
||||
//other options: HashSet (hashcode)
|
||||
// LinkedHashSet (insertion order)
|
||||
// EnumSet (optimized for enum values)
|
||||
//others at: http://download.oracle.com/javase/7/docs/api/java/util/Set.html
|
||||
Set<Integer> b = new TreeSet<>();
|
||||
Set<Integer> c = new TreeSet<>();
|
||||
Set<Integer> d = new TreeSet<>();
|
||||
|
||||
a.addAll(Arrays.asList(1, 2, 3, 4, 5));
|
||||
b.addAll(Arrays.asList(2, 3, 4, 5, 6, 8));
|
||||
c.addAll(Arrays.asList(2, 3, 4));
|
||||
d.addAll(Arrays.asList(2, 3, 4));
|
||||
System.out.println("a: " + a);
|
||||
System.out.println("b: " + b);
|
||||
System.out.println("c: " + c);
|
||||
System.out.println("d: " + d);
|
||||
|
||||
System.out.println("2 in a: " + a.contains(2));
|
||||
System.out.println("6 in a: " + a.contains(6));
|
||||
|
||||
Set<Integer> ab = new TreeSet<>();
|
||||
ab.addAll(a);
|
||||
ab.addAll(b);
|
||||
System.out.println("a union b: " + ab);
|
||||
|
||||
Set<Integer> a_b = new TreeSet<>();
|
||||
a_b.addAll(a);
|
||||
a_b.removeAll(b);
|
||||
System.out.println("a - b: " + a_b);
|
||||
|
||||
System.out.println("c subset of a: " + a.containsAll(c));
|
||||
//use a.conatins() for single elements
|
||||
|
||||
System.out.println("c = d: " + c.equals(d));
|
||||
System.out.println("d = c: " + d.equals(c));
|
||||
|
||||
Set<Integer> aib = new TreeSet<>();
|
||||
aib.addAll(a);
|
||||
aib.retainAll(b);
|
||||
System.out.println("a intersect b: " + aib);
|
||||
|
||||
System.out.println("add 7 to a: " + a.add(7));
|
||||
System.out.println("add 2 to a again: " + a.add(2));
|
||||
|
||||
//other noteworthy things related to sets:
|
||||
Set<Integer> empty = Collections.EMPTY_SET; //immutable empty set
|
||||
//empty.add(2); would fail
|
||||
empty.isEmpty(); //test if a set is empty
|
||||
empty.size();
|
||||
Collections.disjoint(a, b); //returns true if the sets have no common elems (based on their .equals() methods)
|
||||
Collections.unmodifiableSet(a); //returns an immutable copy of a
|
||||
}
|
||||
}
|
||||
148
Task/Set/Liberty-BASIC/set.liberty
Normal file
148
Task/Set/Liberty-BASIC/set.liberty
Normal file
|
|
@ -0,0 +1,148 @@
|
|||
A$ ="red hot chili peppers rule OK"
|
||||
B$ ="lady in red"
|
||||
|
||||
print " New set, in space-separated form. Extra spaces and duplicates will be removed. "
|
||||
input newSet$
|
||||
newSet$ =trim$( newSet$)
|
||||
newSet$ =stripBigSpaces$( newSet$)
|
||||
newSet$ =removeDupes$( newSet$)
|
||||
print " Set stored as the string '"; newSet$; "'"
|
||||
|
||||
print
|
||||
print " 'red' is an element of '"; A$; "' is "; isAnElementOf$( "red", A$)
|
||||
print " 'blue' is an element of '"; A$; "' is "; isAnElementOf$( "blue", A$)
|
||||
print " 'red' is an element of '"; B$; "' is "; isAnElementOf$( "red", B$)
|
||||
print
|
||||
print " Union of '"; A$; "' & '"; B$; "' is '"; unionOf$( A$, B$); "'."
|
||||
print
|
||||
print " Intersection of '"; A$; "' & '"; B$; "' is '"; intersectionOf$( A$, B$); "'."
|
||||
print
|
||||
print " Difference of '"; A$; "' & '"; B$; "' is '"; differenceOf$( A$, B$); "'."
|
||||
print
|
||||
print " '"; A$; "' equals '"; A$; "' is "; equalSets$( A$, A$)
|
||||
print " '"; A$; "' equals '"; B$; "' is "; equalSets$( A$, B$)
|
||||
print
|
||||
print " '"; A$; "' is a subset of '"; B$; "' is "; isSubsetOf$( A$, B$)
|
||||
print " 'red peppers' is a subset of 'red hot chili peppers rule OK' is "; isSubsetOf$( "red peppers", "red hot chili peppers rule OK")
|
||||
|
||||
end
|
||||
|
||||
function removeDupes$( a$)
|
||||
numElements =countElements( a$)
|
||||
redim elArray$( numElements) ' ie 4 elements are array entries 1 to 4 and 0 is spare =""
|
||||
for m =0 to numElements
|
||||
el$ =word$( a$, m, " ")
|
||||
elArray$( m) =el$
|
||||
next m
|
||||
sort elArray$(), 0, numElements
|
||||
b$ =""
|
||||
penultimate$ ="999"
|
||||
for jk =0 to numElements ' do not use "" ( nuls) or elementsalready seen
|
||||
if elArray$( jk) ="" then [on]
|
||||
if elArray$( jk) <>penultimate$ then b$ =b$ +elArray$( jk) +" ": penultimate$ =elArray$( jk)
|
||||
[on]
|
||||
next jk
|
||||
b$ =trim$( b$)
|
||||
removeDupes$ =b$
|
||||
end function
|
||||
|
||||
function stripBigSpaces$( a$) ' copy byte by byte, but id=f a space had a preceding space, ignore it.
|
||||
lenA =len( a$)
|
||||
penul$ =""
|
||||
for i =1 to len( a$)
|
||||
c$ =mid$( a$, i, 1)
|
||||
if c$ <>" " then
|
||||
if penul$ <>" " then
|
||||
b$ =b$ +c$
|
||||
else
|
||||
b$ =b$ +" " +c$
|
||||
end if
|
||||
end if
|
||||
penul$ =c$
|
||||
next i
|
||||
stripBigSpaces$ =b$
|
||||
end function
|
||||
|
||||
function countElements( a$) ' count elements repr'd by space-separated words in string rep'n.
|
||||
if isNul$( a$) ="True" then countElements =0: exit function
|
||||
i =0
|
||||
do
|
||||
el$ =word$( a$, i +1, " ")
|
||||
i =i +1
|
||||
loop until el$ =""
|
||||
countElements =i -1
|
||||
end function
|
||||
|
||||
function isNul$( a$) ' a nul set implies its string rep'n is length zero.
|
||||
if a$ ="" then isNul$ ="True" else isNul$ ="False"
|
||||
end function
|
||||
|
||||
function isAnElementOf$( a$, b$) ' check element a$ exists in set b$.
|
||||
isAnElementOf$ ="False"
|
||||
i =0
|
||||
do
|
||||
el$ =word$( b$, i +1, " ")
|
||||
if a$ =el$ then isAnElementOf$ ="True"
|
||||
i =i +1
|
||||
loop until el$ =""
|
||||
end function
|
||||
|
||||
function unionOf$( a$, b$)
|
||||
i =1
|
||||
o$ =a$
|
||||
do
|
||||
w$ =word$( b$, i, " ")
|
||||
if w$ ="" then exit do
|
||||
if isAnElementOf$( w$, a$) ="False" then o$ =o$ +" " +w$
|
||||
i =i +1
|
||||
loop until w$ =""
|
||||
unionOf$ =o$
|
||||
end function
|
||||
|
||||
function intersectionOf$( a$, b$)
|
||||
i =1
|
||||
o$ =""
|
||||
do
|
||||
el$ =word$( a$, i, " ")
|
||||
if el$ ="" then exit do
|
||||
if ( isAnElementOf$( el$, b$) ="True") and ( o$ ="") then o$ =el$
|
||||
if ( isAnElementOf$( el$, b$) ="True") and ( o$ <>el$) then o$ =o$ +" " +el$
|
||||
i =i +1
|
||||
loop until el$ =""
|
||||
intersectionOf$ =o$
|
||||
end function
|
||||
|
||||
function equalSets$( a$, b$)
|
||||
if len( a$) <>len( b$) then equalSets$ ="False": exit function
|
||||
i =1
|
||||
do
|
||||
el$ =word$( a$, i, " ")
|
||||
if isAnElementOf$( el$, b$) ="False" then equalSets$ ="False": exit function
|
||||
i =i +1
|
||||
loop until w$ =""
|
||||
equalSets$ ="True"
|
||||
end function
|
||||
|
||||
function differenceOf$( a$, b$)
|
||||
i =1
|
||||
o$ =""
|
||||
do
|
||||
el$ =word$( a$, i, " ")
|
||||
if el$ ="" then exit do
|
||||
if ( isAnElementOf$( el$, b$) ="False") and ( o$ ="") then o$ =el$
|
||||
if ( isAnElementOf$( el$, b$) ="False") and ( o$ <>el$) then o$ =o$ +" " +el$
|
||||
i =i +1
|
||||
loop until el$ =""
|
||||
differenceOf$ =o$
|
||||
end function
|
||||
|
||||
function isSubsetOf$( a$, b$)
|
||||
isSubsetOf$ ="True"
|
||||
i =1
|
||||
do
|
||||
el$ =word$( a$, i, " ")
|
||||
if el$ ="" then exit do
|
||||
if ( isAnElementOf$( el$, b$) ="False") then isSubsetOf$ ="False": exit function
|
||||
i =i +1
|
||||
loop until el$ =""
|
||||
end function
|
||||
16
Task/Set/MATLAB/set.m
Normal file
16
Task/Set/MATLAB/set.m
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
% Set creation
|
||||
s = [1, 2, 4]; % numeric values
|
||||
t = {'a','bb','ccc'}; % cell array of strings
|
||||
u = unique([1,2,3,3,2,3,2,4,1]); % set consists only of unique elements
|
||||
% Test m ∈ S -- "m is an element in set S"
|
||||
ismember(m, S)
|
||||
% A ∪ B -- union; a set of all elements either in set A or in set B.
|
||||
union(A, B)
|
||||
% A ∩ B -- intersection; a set of all elements in both set A and set B.
|
||||
intersect(A, B)
|
||||
% A ∖ B -- difference; a set of all elements in set A, except those in set B.
|
||||
setdiff(A, B)
|
||||
% A ⊆ B -- subset; true if every element in set A is also in set B.
|
||||
all(ismember(A, B))
|
||||
% A = B -- equality; true if every element of set A is in set B and vice-versa.
|
||||
isempty(setxor(A, B))
|
||||
41
Task/Set/Maple/set.maple
Normal file
41
Task/Set/Maple/set.maple
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
> 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}}
|
||||
|
||||
> type( S, set );
|
||||
true
|
||||
|
||||
> Pi in S;
|
||||
Pi in {2, 3, 5, 7, 11, "foo", Pi, {2/3, 3/4, 4/5}}
|
||||
|
||||
> if Pi in S then print( yes ) else print( no ) end:
|
||||
yes
|
||||
|
||||
> member( Pi, S );
|
||||
true
|
||||
|
||||
> if 4 in S then print( yes ) else print( no ) end:
|
||||
no
|
||||
|
||||
> evalb( { 2/3, 3/4, 4/5 } in S );
|
||||
true
|
||||
|
||||
> { a, b, c } union { 1, 2, 3 };
|
||||
{1, 2, 3, a, b, c}
|
||||
|
||||
> { a, b, c } intersect { b, c, d };
|
||||
{b, c}
|
||||
|
||||
> { a, b, c } minus { b, c, d };
|
||||
{a}
|
||||
|
||||
> { a, b } subset { a, b, c };
|
||||
true
|
||||
|
||||
> { a, d } subset { a, b, c };
|
||||
false
|
||||
|
||||
> evalb( { 1, 2, 3 } = { 1, 2, 3 } );
|
||||
true
|
||||
|
||||
> evalb( { 1, 2, 3 } = { 1, 2, 4 } );
|
||||
false
|
||||
8
Task/Set/Mathematica/set.math
Normal file
8
Task/Set/Mathematica/set.math
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
set1 = {"a", "b", "c", "d", "e"}; set2 = {"a", "b", "c", "d", "e", "f", "g"};
|
||||
MemberQ[set1, "a"]
|
||||
Union[set1 , set2]
|
||||
Intersection[set1 , set2]
|
||||
Complement[set2, set1](*Set Difference*)
|
||||
MemberQ[Subsets[set2], set1](*Subset*)
|
||||
set1 == set2(*Equality*)
|
||||
set1 == set1(*Equality*)
|
||||
78
Task/Set/Maxima/set.maxima
Normal file
78
Task/Set/Maxima/set.maxima
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
/* illustrating some functions on sets; names are self-explanatory */
|
||||
|
||||
a: {1, 2, 3, 4};
|
||||
{1, 2, 3, 4}
|
||||
|
||||
b: {2, 4, 6, 8};
|
||||
{2, 4, 6, 8}
|
||||
|
||||
intersection(a, b);
|
||||
{2, 4}
|
||||
|
||||
union(a, b);
|
||||
{1, 2, 3, 4, 6, 8}
|
||||
|
||||
powerset(a);
|
||||
{{}, {1}, {1, 2}, {1, 2, 3}, {1, 2, 3, 4}, {1, 2, 4}, {1, 3}, {1, 3, 4}, {1, 4}, {2}, {2, 3}, {2, 3, 4}, {2, 4}, {3}, {3, 4}, {4}}
|
||||
|
||||
set_partitions(a);
|
||||
{{{1}, {2}, {3}, {4}}, {{1}, {2}, {3, 4}}, {{1}, {2, 3}, {4}}, {{1}, {2, 3, 4}}, {{1}, {2, 4}, {3}}, {{1, 2}, {3}, {4}},
|
||||
{{1, 2}, {3, 4}}, {{1, 2, 3}, {4}}, {{1, 2, 3, 4}}, {{1, 2, 4}, {3}}, {{1, 3}, {2}, {4}}, {{1, 3}, {2, 4}}, {{1, 3, 4}, {2}},
|
||||
{{1, 4}, {2}, {3}}, {{1, 4}, {2, 3}}}
|
||||
|
||||
setdifference(a, b);
|
||||
{1, 3}
|
||||
|
||||
emptyp(a);
|
||||
false
|
||||
|
||||
elementp(2, a);
|
||||
true
|
||||
|
||||
cardinality(a);
|
||||
4
|
||||
|
||||
cartesian_product(a, b);
|
||||
{[1, 2], [1, 4], [1, 6], [1, 8], [2, 2], [2, 4], [2, 6], [2, 8], [3, 2], [3, 4], [3, 6], [3, 8], [4, 2], [4, 4], [4, 6], [4, 8]}
|
||||
|
||||
subsetp(a, b);
|
||||
false
|
||||
|
||||
symmdifference(a, b);
|
||||
{1, 3, 6, 8}
|
||||
|
||||
partition_set(union(a, b), evenp);
|
||||
[{1, 3}, {2, 4, 6, 8}]
|
||||
|
||||
c: setify(makelist(fib(n), n, 1, 20));
|
||||
{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765}
|
||||
|
||||
equiv_classes(c, lambda([m, n], mod(m - n, 3) = 0));
|
||||
{{1, 13, 34, 55, 610, 1597, 2584}, {2, 5, 8, 89, 233, 377, 4181}, {3, 21, 144, 987, 6765}}
|
||||
|
||||
disjointp(a, b);
|
||||
false
|
||||
|
||||
adjoin(7, a);
|
||||
{1, 2, 3, 4, 7}
|
||||
|
||||
a;
|
||||
{1, 2, 3, 4}
|
||||
|
||||
disjoin(1, a);
|
||||
{2, 3, 4}
|
||||
|
||||
a;
|
||||
{1, 2, 3, 4}
|
||||
|
||||
subset(c, primep);
|
||||
{2, 3, 5, 13, 89, 233, 1597}
|
||||
|
||||
permutations(a);
|
||||
{[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 4, 2], [1, 4, 2, 3], [1, 4, 3, 2],
|
||||
[2, 1, 3, 4], [2, 1, 4, 3], [2, 3, 1, 4], [2, 3, 4, 1], [2, 4, 1, 3], [2, 4, 3, 1],
|
||||
[3, 1, 2, 4], [3, 1, 4, 2], [3, 2, 1, 4], [3, 2, 4, 1], [3, 4, 1, 2], [3, 4, 2, 1],
|
||||
[4, 1, 2, 3], [4, 1, 3, 2], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]}
|
||||
|
||||
setequalp(a, b);
|
||||
false
|
||||
68
Task/Set/OCaml/set.ocaml
Normal file
68
Task/Set/OCaml/set.ocaml
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
# module IntSet = Set.Make(struct type t = int let compare = compare end);; (* Create a module for our type of set *)
|
||||
module IntSet :
|
||||
sig
|
||||
type elt = int
|
||||
type t
|
||||
val empty : t
|
||||
val is_empty : t -> bool
|
||||
val mem : elt -> t -> bool
|
||||
val add : elt -> t -> t
|
||||
val singleton : elt -> t
|
||||
val remove : elt -> t -> t
|
||||
val union : t -> t -> t
|
||||
val inter : t -> t -> t
|
||||
val diff : t -> t -> t
|
||||
val compare : t -> t -> int
|
||||
val equal : t -> t -> bool
|
||||
val subset : t -> t -> bool
|
||||
val iter : (elt -> unit) -> t -> unit
|
||||
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
|
||||
val for_all : (elt -> bool) -> t -> bool
|
||||
val exists : (elt -> bool) -> t -> bool
|
||||
val filter : (elt -> bool) -> t -> t
|
||||
val partition : (elt -> bool) -> t -> t * t
|
||||
val cardinal : t -> int
|
||||
val elements : t -> elt list
|
||||
val min_elt : t -> elt
|
||||
val max_elt : t -> elt
|
||||
val choose : t -> elt
|
||||
val split : elt -> t -> t * bool * t
|
||||
end
|
||||
# IntSet.empty;; (* Empty set. A set is an abstract type that will not display in the interpreter *)
|
||||
- : IntSet.t = <abstr>
|
||||
# IntSet.elements (IntSet.empty);; (* Get the previous set into a list *)
|
||||
- : IntSet.elt list = []
|
||||
# let from_list lst = List.fold_right IntSet.add lst IntSet.empty;; (* Convenience function for constructing a set from a list *)
|
||||
val from_list : IntSet.elt list -> IntSet.t = <fun>
|
||||
# let s1 = from_list [1;2;3;4;3];;
|
||||
val s1 : IntSet.t = <abstr>
|
||||
# IntSet.elements s1;;
|
||||
- : IntSet.elt list = [1; 2; 3; 4]
|
||||
# let s2 = from_list [3;4;5;6];;
|
||||
val s2 : IntSet.t = <abstr>
|
||||
# IntSet.elements s2;;
|
||||
- : IntSet.elt list = [3; 4; 5; 6]
|
||||
# IntSet.elements (IntSet.union s1 s2);; (* Union *)
|
||||
- : IntSet.elt list = [1; 2; 3; 4; 5; 6]
|
||||
# IntSet.elements (IntSet.inter s1 s2);; (* Intersection *)
|
||||
- : IntSet.elt list = [3; 4]
|
||||
# IntSet.elements (IntSet.diff s1 s2);; (* Difference *)
|
||||
- : IntSet.elt list = [1; 2]
|
||||
# IntSet.subset s1 s1;; (* Subset *)
|
||||
- : bool = true
|
||||
# IntSet.subset (from_list [3;1]) s1;;
|
||||
- : bool = true
|
||||
# IntSet.equal (from_list [3;2;4;1]) s1;; (* Equality *)
|
||||
- : bool = true
|
||||
# IntSet.equal s1 s2;;
|
||||
- : bool = false
|
||||
# IntSet.mem 2 s1;; (* Membership *)
|
||||
- : bool = true
|
||||
# IntSet.mem 10 s1;;
|
||||
- : bool = false
|
||||
# IntSet.cardinal s1;; (* Cardinality *)
|
||||
- : int = 4
|
||||
# IntSet.elements (IntSet.add 99 s1);; (* Create a new set by inserting *)
|
||||
- : IntSet.elt list = [1; 2; 3; 4; 99]
|
||||
# IntSet.elements (IntSet.remove 3 s1);; (* Create a new set by deleting *)
|
||||
- : IntSet.elt list = [1; 2; 4]
|
||||
57
Task/Set/Objective-C/set.m
Normal file
57
Task/Set/Objective-C/set.m
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
#import <Foundation/Foundation.h>
|
||||
|
||||
int main (int argc, const char *argv[]) {
|
||||
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
|
||||
|
||||
NSSet *s1 = [NSSet setWithObjects:@"a", @"b", @"c", @"d", @"e", nil];
|
||||
NSSet *s2 = [NSSet setWithObjects:@"b", @"c", @"d", @"e", @"f", @"h", nil];
|
||||
NSSet *s3 = [NSSet setWithObjects:@"b", @"c", @"d", nil];
|
||||
NSSet *s4 = [NSSet setWithObjects:@"b", @"c", @"d", nil];
|
||||
NSLog(@"s1: %@", s1);
|
||||
NSLog(@"s2: %@", s2);
|
||||
NSLog(@"s3: %@", s3);
|
||||
NSLog(@"s4: %@", s4);
|
||||
|
||||
// Membership
|
||||
NSLog(@"b in s1: %d", [s1 containsObject:@"b"]);
|
||||
NSLog(@"f in s1: %d", [s1 containsObject:@"f"]);
|
||||
|
||||
// Union
|
||||
NSMutableSet *s12 = [NSMutableSet setWithSet:s1];
|
||||
[s12 unionSet:s2];
|
||||
NSLog(@"s1 union s2: %@", s12);
|
||||
|
||||
// Intersection
|
||||
NSMutableSet *s1i2 = [NSMutableSet setWithSet:s1];
|
||||
[s1i2 intersectSet:s2];
|
||||
NSLog(@"s1 intersect s2: %@", s1i2);
|
||||
|
||||
// Difference
|
||||
NSMutableSet *s1_2 = [NSMutableSet setWithSet:s1];
|
||||
[s1_2 minusSet:s2];
|
||||
NSLog(@"s1 - s2: %@", s1_2);
|
||||
|
||||
// Subset of
|
||||
NSLog(@"s3 subset of s1: %d", [s3 isSubsetOfSet:s1]);
|
||||
|
||||
// Equality
|
||||
NSLog(@"s3 = s4: %d", [s3 isEqualToSet:s4]);
|
||||
|
||||
// Cardinality
|
||||
NSLog(@"size of s1: %lu", [s1 count]);
|
||||
|
||||
// Has intersection (not disjoint)
|
||||
NSLog(@"does s1 intersect s2? %d", [s1 intersectsSet:s2]);
|
||||
|
||||
// Adding and removing elements from a mutable set
|
||||
NSMutableSet *mut_s1 = [NSMutableSet setWithSet:s1];
|
||||
[mut_s1 addObject:@"g"];
|
||||
NSLog(@"mut_s1 after adding g: %@", mut_s1);
|
||||
[mut_s1 addObject:@"b"];
|
||||
NSLog(@"mut_s1 after adding b again: %@", mut_s1);
|
||||
[mut_s1 removeObject:@"c"];
|
||||
NSLog(@"mut_s1 after removing c: %@", mut_s1);
|
||||
|
||||
[pool release];
|
||||
return 0;
|
||||
}
|
||||
14
Task/Set/PARI-GP/set.pari
Normal file
14
Task/Set/PARI-GP/set.pari
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
setsubset(s,t)={
|
||||
for(i=1,#s,
|
||||
if(!setsearch(t,s[i]), return(0))
|
||||
);
|
||||
1
|
||||
};
|
||||
s=Set([1,2,2])
|
||||
t=Set([4,2,4])
|
||||
setsearch(s,1)
|
||||
setunion(s,t)
|
||||
setintersect(s,t)
|
||||
setminus(s,t)
|
||||
setsubset(s,t)
|
||||
s==t
|
||||
94
Task/Set/Pascal/set.pascal
Normal file
94
Task/Set/Pascal/set.pascal
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
program Rosetta_Set;
|
||||
|
||||
{$mode objfpc}{$H+}
|
||||
|
||||
uses {$IFDEF UNIX} {$IFDEF UseCThreads}
|
||||
cthreads, {$ENDIF} {$ENDIF}
|
||||
Classes;
|
||||
|
||||
{$R *.res}
|
||||
type
|
||||
CharSet = set of char;
|
||||
|
||||
var
|
||||
A, B, C, S: CharSet;
|
||||
M: char;
|
||||
|
||||
function SetToString(const ASet: CharSet): string;
|
||||
var
|
||||
J: char;
|
||||
begin
|
||||
Result := '';
|
||||
// Test all chars
|
||||
for J in char do
|
||||
// If the char is in set, add to result
|
||||
if J in ASet then
|
||||
Result := Result + J + ', ';
|
||||
// Clear the result
|
||||
if Result > '' then
|
||||
Delete(Result, Length(Result) - 1, 2);
|
||||
end;
|
||||
|
||||
procedure PrintSet(const ASet: CharSet; const ASetName: string;
|
||||
const ATitle: string = '');
|
||||
begin
|
||||
if ATitle > '' then
|
||||
WriteLn(ATitle);
|
||||
WriteLn(ASetName, ' = [', SetToString(ASet), ']', #10);
|
||||
end;
|
||||
|
||||
procedure ShowEqual(const ASetA, ASetB: CharSet; const ASetNameA, ASetNameB: string);
|
||||
begin
|
||||
WriteLn(ASetNameA, ' = [', SetToString(ASetA), ']');
|
||||
WriteLn(ASetNameB, ' = [', SetToString(ASetB), ']');
|
||||
if ASetA = ASetB then
|
||||
WriteLn(ASetNameA, ' = ', ASetNameB)
|
||||
else
|
||||
WriteLn(ASetNameA, ' <> ', ASetNameB);
|
||||
end;
|
||||
|
||||
|
||||
begin
|
||||
// Set Creation
|
||||
A := ['A', 'B', 'C', 'D', 'E', 'F'];
|
||||
B := ['E', 'F', 'G', 'H', 'I', 'J'];
|
||||
PrintSet(A, 'A', 'Set Creation');
|
||||
PrintSet(B, 'B');
|
||||
|
||||
// Test m ∈ S -- "m is an element in set S"
|
||||
M := 'A';
|
||||
if M in A then
|
||||
WriteLn('"A" is in set A');
|
||||
|
||||
// A ∪ B -- union; a set of all elements either in set A or in set B.
|
||||
S := A + B;
|
||||
PrintSet(S, 'S', 'S = A U B -- union; a set of all elements either in set A or in set B.');
|
||||
|
||||
// A ∩ B -- intersection; a set of all elements in both set A and set B.
|
||||
S := A * B;
|
||||
PrintSet(S, 'S',
|
||||
'S = A ∩ B -- intersection; a set of all elements in both set A and set B.');
|
||||
|
||||
// A \ B -- difference; a set of all elements in set A, except those in set B.
|
||||
S := A - B;
|
||||
PrintSet(S, 'S',
|
||||
'S = A \ B -- difference; a set of all elements in set A, except those in set B.');
|
||||
|
||||
// A ⊆ B -- subset; true if every element in set A is also in set B.
|
||||
Writeln('A ⊆ B -- subset; true if every element in set A is also in set B.');
|
||||
if A <= B then
|
||||
WriteLn('A in B')
|
||||
else
|
||||
Writeln('A is not in B');
|
||||
Writeln;
|
||||
//A = B -- equality; true if every element of set A is in set B and vice-versa.
|
||||
Writeln('A = B -- equality; true if every element of set A is in set B and vice-versa.');
|
||||
|
||||
ShowEqual(A, B, 'A', 'B');
|
||||
S := A * B;
|
||||
C := ['E', 'F'];
|
||||
ShowEqual(S, C, 'S', 'C');
|
||||
|
||||
readln;
|
||||
|
||||
end.
|
||||
19
Task/Set/Perl-6/set.pl6
Normal file
19
Task/Set/Perl-6/set.pl6
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
use Test;
|
||||
|
||||
my $a = set <a b c>;
|
||||
my $b = set <b c d>;
|
||||
my $c = set <a b c d e>;
|
||||
|
||||
ok 'c' ∈ $a, "c is an element in set A";
|
||||
nok 'd' ∈ $a, "d is not an element in set A";
|
||||
|
||||
is $a ∪ $b, set(<a b c d>), "union; a set of all elements either in set A or in set B";
|
||||
is $a ∩ $b, set(<b c>), "intersection; a set of all elements in both set A and set B";
|
||||
is $a (-) $b, set(<a>), "difference; a set of all elements in set A, except those in set B";
|
||||
|
||||
ok $a ⊆ $c, "subset; true if every element in set A is also in set B";
|
||||
nok $c ⊆ $a, "subset; false if every element in set A is not also in set B";
|
||||
ok $a ⊂ $c, "strict subset; true if every element in set A is also in set B";
|
||||
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";
|
||||
nok $a === $b, "equality; false for differing sets";
|
||||
113
Task/Set/Perl/set.pl
Normal file
113
Task/Set/Perl/set.pl
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
use strict;
|
||||
|
||||
package Set; # likely will conflict with stuff on CPAN
|
||||
use overload
|
||||
'""' => \&str,
|
||||
'bool' => \&count,
|
||||
'+=' => \&add,
|
||||
'-=' => \&del,
|
||||
'-' => \&diff,
|
||||
'==' => \&eq,
|
||||
'&' => \&intersection,
|
||||
'|' => \&union,
|
||||
'^' => \&xdiff;
|
||||
|
||||
sub str {
|
||||
my $set = shift;
|
||||
# This has drawbacks: stringification is used as set key
|
||||
# if the set is added to another set as an element, which
|
||||
# may cause inconsistencies if the element set is modified
|
||||
# later. In general, a hash key loses its object identity
|
||||
# anyway, so it's not unique to us.
|
||||
"Set{ ". join(", " => sort map("$_", values %$set)) . " }"
|
||||
}
|
||||
|
||||
sub new {
|
||||
my $pkg = shift;
|
||||
my $h = bless {};
|
||||
$h->add($_) for @_;
|
||||
$h
|
||||
}
|
||||
|
||||
sub add {
|
||||
my ($set, $elem) = @_;
|
||||
$set->{$elem} = $elem;
|
||||
$set
|
||||
}
|
||||
|
||||
sub del {
|
||||
my ($set, $elem) = @_;
|
||||
delete $set->{$elem};
|
||||
$set
|
||||
}
|
||||
|
||||
sub has { # set has element
|
||||
my ($set, $elem) = @_;
|
||||
exists $set->{$elem}
|
||||
}
|
||||
|
||||
sub union {
|
||||
my ($this, $that) = @_;
|
||||
bless { %$this, %$that }
|
||||
}
|
||||
|
||||
sub intersection {
|
||||
my ($this, $that) = @_;
|
||||
my $s = new Set;
|
||||
for (keys %$this) {
|
||||
$s->{$_} = $this->{$_} if exists $that->{$_}
|
||||
}
|
||||
$s
|
||||
}
|
||||
|
||||
sub diff {
|
||||
my ($this, $that) = @_;
|
||||
my $s = Set->new;
|
||||
for (keys %$this) {
|
||||
$s += $this->{$_} unless exists $that->{$_}
|
||||
}
|
||||
$s
|
||||
}
|
||||
|
||||
sub xdiff { # xor, symmetric diff
|
||||
my ($this, $that) = @_;
|
||||
my $s = new Set;
|
||||
bless { %{ ($this - $that) | ($that - $this) } }
|
||||
}
|
||||
|
||||
sub count { scalar(keys %{+shift}) }
|
||||
|
||||
sub eq {
|
||||
my ($this, $that) = @_;
|
||||
!($this - $that) && !($that - $this);
|
||||
}
|
||||
|
||||
sub contains { # this is a superset of that
|
||||
my ($this, $that) = @_;
|
||||
for (keys %$that) {
|
||||
return 0 unless $this->has($_)
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
package main;
|
||||
my ($x, $y, $z, $w);
|
||||
|
||||
$x = Set->new(1, 2, 3);
|
||||
$x += $_ for (5 .. 7);
|
||||
$y = Set->new(1, 2, 4, $x); # not the brightest idea
|
||||
|
||||
print "set x is: $x\nset y is: $y\n";
|
||||
for (1 .. 4, $x) {
|
||||
print "$_ is", $y->has($_) ? "" : " not", " in y\n";
|
||||
}
|
||||
|
||||
print "union: ", $x | $y, "\n";
|
||||
print "intersect: ", $x & $y, "\n";
|
||||
print "z = x - y = ", $z = $x - $y, "\n";
|
||||
print "y is ", $x->contains($y) ? "" : "not ", "a subset of x\n";
|
||||
print "z is ", $x->contains($z) ? "" : "not ", "a subset of x\n";
|
||||
print "z = (x | y) - (x & y) = ", $z = ($x | $y) - ($x & $y), "\n";
|
||||
print "w = x ^ y = ", $w = ($x ^ $y), "\n";
|
||||
print "w is ", ($w == $z) ? "" : "not ", "equal to z\n";
|
||||
print "w is ", ($w == $x) ? "" : "not ", "equal to x\n";
|
||||
46
Task/Set/PicoLisp/set-1.l
Normal file
46
Task/Set/PicoLisp/set-1.l
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
(setq
|
||||
Set1 (1 2 3 7 abc "def" (u v w))
|
||||
Set2 (2 3 5 hello (x y z))
|
||||
Set3 (3 hello (x y z)) )
|
||||
|
||||
|
||||
# Element tests (any non-NIL value means "yes")
|
||||
: (member "def" Set1)
|
||||
-> ("def" (u v w))
|
||||
|
||||
: (member "def" Set2)
|
||||
-> NIL
|
||||
|
||||
: (member '(x y z) Set2)
|
||||
-> ((x y z))
|
||||
|
||||
|
||||
# Union
|
||||
: (uniq (append Set1 Set2))
|
||||
-> (1 2 3 7 abc "def" (u v w) 5 hello (x y z))
|
||||
|
||||
|
||||
# Intersection
|
||||
: (sect Set1 Set2)
|
||||
-> (2 3)
|
||||
|
||||
|
||||
# Difference
|
||||
: (diff Set1 Set2)
|
||||
-> (1 7 abc "def" (u v w))
|
||||
|
||||
|
||||
# Test for subset
|
||||
: (not (diff Set1 Set2))
|
||||
-> NIL # Set1 is not a subset of Set2
|
||||
|
||||
: (not (diff Set3 Set2))
|
||||
-> T # Set3 is a subset of Set2
|
||||
|
||||
|
||||
# Test for equality
|
||||
: (= (sort (copy Set1)) (sort (copy Set2)))
|
||||
-> NIL
|
||||
|
||||
: (= (sort (copy Set2)) (sort (copy Set2)))
|
||||
-> T
|
||||
57
Task/Set/PicoLisp/set-2.l
Normal file
57
Task/Set/PicoLisp/set-2.l
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
# Create three test-sets
|
||||
(balance 'Set1 (1 2 3 7 abc "def" (u v w)))
|
||||
(balance 'Set2 (2 3 5 hello (x y z)))
|
||||
(balance 'Set3 (3 hello (x y z)))
|
||||
|
||||
|
||||
# Get contents
|
||||
: (idx 'Set1)
|
||||
-> (1 2 3 7 abc "def" (u v w))
|
||||
|
||||
: (idx 'Set2)
|
||||
-> (2 3 5 hello (x y z))
|
||||
|
||||
|
||||
# Element tests (any non-NIL value means "yes")
|
||||
: (idx 'Set1 "def")
|
||||
-> ("def" (abc) (u v w))
|
||||
|
||||
: (idx 'Set2 "def")
|
||||
-> NIL
|
||||
|
||||
: (idx 'Set2 '(x y z))
|
||||
-> ((x y z))
|
||||
|
||||
|
||||
# Union
|
||||
: (use S
|
||||
(balance 'S (idx 'Set1))
|
||||
(balance 'S (idx 'Set2) T)
|
||||
(idx 'S) )
|
||||
-> (1 2 3 5 7 abc "def" hello (u v w) (x y z))
|
||||
|
||||
|
||||
# Intersection
|
||||
: (sect (idx 'Set1) (idx 'Set2))
|
||||
-> (2 3)
|
||||
|
||||
|
||||
# Difference
|
||||
: (diff (idx 'Set1) (idx 'Set2))
|
||||
-> (1 7 abc "def" (u v w))
|
||||
|
||||
|
||||
# Test for subset
|
||||
: (not (diff (idx 'Set1) (idx 'Set2)))
|
||||
-> NIL # Set1 is not a subset of Set2
|
||||
|
||||
: (not (diff (idx 'Set3) (idx 'Set2)))
|
||||
-> T # Set3 is a subset of Set2
|
||||
|
||||
|
||||
# Test for equality
|
||||
: (= (idx 'Set1) (idx 'Set2))
|
||||
-> NIL
|
||||
|
||||
: (= (idx 'Set2) (idx 'Set2))
|
||||
-> T
|
||||
49
Task/Set/Prolog/set.pro
Normal file
49
Task/Set/Prolog/set.pro
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
:- use_module(library(lists)).
|
||||
|
||||
set :-
|
||||
A = [2, 4, 1, 3],
|
||||
B = [5, 2, 3, 2],
|
||||
( is_set(A) -> format('~w is a set~n', [A])
|
||||
; format('~w is not a set~n', [A])),
|
||||
( is_set(B) -> format('~w is a set~n', [B])
|
||||
; format('~w is not a set~n', [B])),
|
||||
|
||||
% create a set from a list
|
||||
|
||||
list_to_set(B, BS),
|
||||
( is_set(BS) -> format('~nCreate a set from a list~n~w is a set~n', [BS])
|
||||
; format('~w is not a set~n', [BS])),
|
||||
|
||||
intersection(A, BS, I),
|
||||
format('~n~w intersection ~w => ~w~n', [A, BS, I]),
|
||||
union(A, BS, U),
|
||||
format('~w union ~w => ~w~n', [A, BS, U]),
|
||||
difference(A, BS, D),
|
||||
format('~w difference ~w => ~w~n', [A, BS, D]),
|
||||
|
||||
X = [1,2],
|
||||
( subset(X, A) -> format('~n~w is a subset of ~w~n', [X, A])
|
||||
; format('~w is not a subset of ~w~n', [X, A])),
|
||||
Y = [1,5],
|
||||
( subset(Y, A) -> format('~w is a subset of ~w~n', [Y, A])
|
||||
; format('~w is not a subset of ~w~n', [Y, A])),
|
||||
Z = [1, 2, 3, 4],
|
||||
( equal(Z, A) -> format('~n~w is equal to ~w~n', [Z, A])
|
||||
; format('~w is not equal to ~w~n', [Z, A])),
|
||||
T = [1, 2, 3],
|
||||
( equal(T, A) -> format('~w is equal to ~w~n', [T, A])
|
||||
; format('~w is not equal to ~w~n', [T, A])).
|
||||
|
||||
|
||||
|
||||
% compute difference of sets
|
||||
difference(A, B, D) :-
|
||||
exclude(member_(B), A, D).
|
||||
|
||||
member_(L, X) :-
|
||||
member(X, L).
|
||||
|
||||
equal([], []).
|
||||
equal([H1 | T1], B) :-
|
||||
select(H1, B, B1),
|
||||
equal(T1, B1).
|
||||
170
Task/Set/PureBasic/set.purebasic
Normal file
170
Task/Set/PureBasic/set.purebasic
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
Procedure.s booleanText(b) ;returns 'True' or 'False' for a boolean input
|
||||
If b: ProcedureReturn "True": EndIf
|
||||
ProcedureReturn "False"
|
||||
EndProcedure
|
||||
|
||||
Procedure.s listSetElements(Map a(), delimeter.s = " ") ;format elements for display
|
||||
Protected output$
|
||||
|
||||
ForEach a()
|
||||
output$ + MapKey(a()) + delimeter
|
||||
Next
|
||||
|
||||
ProcedureReturn "(" + RTrim(output$, delimeter) + ")"
|
||||
EndProcedure
|
||||
|
||||
Procedure.s listSortedSetElements(Map a(), delimeter.s = " ") ;format elements for display as sorted for easy comparison
|
||||
Protected output$
|
||||
NewList b.s()
|
||||
|
||||
ForEach a()
|
||||
AddElement(b()): b() = MapKey(a())
|
||||
Next
|
||||
SortList(b(), #PB_Sort_Ascending | #PB_Sort_NoCase)
|
||||
ForEach b()
|
||||
output$ + b() + delimeter
|
||||
Next
|
||||
|
||||
ProcedureReturn "(" + RTrim(output$, delimeter) + ")"
|
||||
EndProcedure
|
||||
|
||||
Procedure cardinalityOf(Map a())
|
||||
ProcedureReturn MapSize(a())
|
||||
EndProcedure
|
||||
|
||||
Procedure createSet(elements.s, Map o(), delimeter.s = " ", clearSet = 1)
|
||||
Protected i, elementCount
|
||||
|
||||
If clearSet: ClearMap(o()): EndIf
|
||||
elementCount = CountString(elements, delimeter) + 1 ;add one for the last element which won't have a delimeter
|
||||
For i = 1 To elementCount
|
||||
AddMapElement(o(), StringField(elements, i, delimeter))
|
||||
Next
|
||||
|
||||
ProcedureReturn MapSize(o())
|
||||
EndProcedure
|
||||
|
||||
Procedure adjoinTo(elements.s, Map o(), delimeter.s = " ")
|
||||
ProcedureReturn createSet(elements, o(), delimeter, 0)
|
||||
EndProcedure
|
||||
|
||||
Procedure disjoinFrom(elements.s, Map o(), delimeter.s = " ")
|
||||
Protected i, elementCount
|
||||
|
||||
elementCount = CountString(elements, delimeter) + 1 ;add one for the last element which won't have a delimeter
|
||||
For i = 1 To elementCount
|
||||
DeleteMapElement(o(), StringField(elements, i, delimeter))
|
||||
Next
|
||||
|
||||
ProcedureReturn MapSize(o())
|
||||
EndProcedure
|
||||
|
||||
Procedure isElementOf(element.s, Map a())
|
||||
ProcedureReturn FindMapElement(a(), element)
|
||||
EndProcedure
|
||||
|
||||
|
||||
|
||||
Procedure unionOf(Map a(), Map b(), Map o())
|
||||
CopyMap(a(), o())
|
||||
ForEach b()
|
||||
AddMapElement(o(), MapKey(b()))
|
||||
Next
|
||||
|
||||
ProcedureReturn MapSize(o())
|
||||
EndProcedure
|
||||
|
||||
Procedure intersectionOf(Map a(), Map b(), Map o())
|
||||
ClearMap(o())
|
||||
ForEach a()
|
||||
If FindMapElement(b(), MapKey(a()))
|
||||
AddMapElement(o(), MapKey(a()))
|
||||
EndIf
|
||||
Next
|
||||
|
||||
ProcedureReturn MapSize(o())
|
||||
EndProcedure
|
||||
|
||||
Procedure differenceOf(Map a(), Map b(), Map o())
|
||||
CopyMap(a(), o())
|
||||
ForEach b()
|
||||
If FindMapElement(o(), MapKey(b()))
|
||||
DeleteMapElement(o())
|
||||
Else
|
||||
AddMapElement(o(), MapKey(b()))
|
||||
EndIf
|
||||
Next
|
||||
|
||||
ProcedureReturn MapSize(o())
|
||||
EndProcedure
|
||||
|
||||
Procedure isSubsetOf(Map a(), Map b()) ;boolean
|
||||
ForEach a()
|
||||
If Not FindMapElement(b(), MapKey(a()))
|
||||
ProcedureReturn 0
|
||||
EndIf
|
||||
Next
|
||||
ProcedureReturn 1
|
||||
EndProcedure
|
||||
|
||||
Procedure isProperSubsetOf(Map a(), Map b()) ;boolean
|
||||
If MapSize(a()) = MapSize(b())
|
||||
ProcedureReturn 0
|
||||
EndIf
|
||||
ProcedureReturn isSubsetOf(a(), b())
|
||||
EndProcedure
|
||||
|
||||
Procedure isEqualTo(Map a(), Map b())
|
||||
If MapSize(a()) = MapSize(b())
|
||||
ProcedureReturn isSubsetOf(a(), b())
|
||||
EndIf
|
||||
ProcedureReturn 0
|
||||
EndProcedure
|
||||
|
||||
Procedure isEmpty(Map a()) ;boolean
|
||||
If MapSize(a())
|
||||
ProcedureReturn 0
|
||||
EndIf
|
||||
ProcedureReturn 1
|
||||
EndProcedure
|
||||
|
||||
If OpenConsole()
|
||||
NewMap a()
|
||||
NewMap b()
|
||||
NewMap o() ;for output sets
|
||||
NewMap c()
|
||||
|
||||
createSet("red blue green orange yellow", a())
|
||||
PrintN("Set A = " + listSortedSetElements(a()) + " of cardinality " + Str(cardinalityOf(a())) + ".")
|
||||
createSet("lady green red", b())
|
||||
PrintN("Set B = " + listSortedSetElements(b()) + " of cardinality " + Str(cardinalityOf(b())) + ".")
|
||||
PrintN("'red' is an element of A is " + booleanText(isElementOf("red", a())) + ".")
|
||||
PrintN("'red' is an element of B is " + booleanText(isElementOf("red", b())) + ".")
|
||||
PrintN("'blue' is an element of B is " + booleanText(isElementOf("blue", b())) + ".")
|
||||
|
||||
unionOf(a(), b(), o())
|
||||
PrintN(#crlf$ + "Union of A & B is " + listSortedSetElements(o()) + ".")
|
||||
intersectionOf(a(), b(), o())
|
||||
PrintN("Intersection of A & B is " + listSortedSetElements(o()) + ".")
|
||||
differenceOf(a(), b(), o())
|
||||
PrintN("Difference of A & B is " + listSortedSetElements(o()) + ".")
|
||||
|
||||
PrintN(listSortedSetElements(a()) + " equals " + listSortedSetElements(a()) + " is " + booleanText(isEqualTo(a(), a())) + ".")
|
||||
PrintN(listSortedSetElements(a()) + " equals " + listSortedSetElements(b()) + " is " + booleanText(isEqualTo(a(), b())) + ".")
|
||||
|
||||
createSet("red green", c())
|
||||
PrintN(#crlf$ + listSortedSetElements(c()) + " is a subset of " + listSortedSetElements(a()) + " is "+ booleanText(isSubsetOf(c(), a())) + ".")
|
||||
PrintN(listSortedSetElements(c()) + " is a proper subset of " + listSortedSetElements(b()) + " is "+ booleanText(isProperSubsetOf(c(), b())) + ".")
|
||||
PrintN(listSortedSetElements(c()) + " is a proper subset of " + listSortedSetElements(a()) + " is "+ booleanText(isProperSubsetOf(c(), a())) + ".")
|
||||
PrintN(listSortedSetElements(b()) + " is a proper subset of " + listSortedSetElements(b()) + " is "+ booleanText(isProperSubsetOf(b(), b())) + ".")
|
||||
|
||||
PrintN(#crlf$ + "Set C = " + listSortedSetElements(c()) + " of cardinality " + Str(cardinalityOf(c())) + ".")
|
||||
adjoinTo("dog cat mouse", c())
|
||||
PrintN("Add 'dog cat mouse' to C to get " + listSortedSetElements(c()) + " of cardinality " + Str(cardinalityOf(c())) + ".")
|
||||
disjoinFrom("red green dog", c())
|
||||
PrintN("Take away 'red green dog' from C to get " + listSortedSetElements(c()) + " of cardinality " + Str(cardinalityOf(c())) + ".")
|
||||
|
||||
|
||||
Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()
|
||||
CloseConsole()
|
||||
EndIf
|
||||
49
Task/Set/Python/set.py
Normal file
49
Task/Set/Python/set.py
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
>>> s1, s2 = {1, 2, 3, 4}, {3, 4, 5, 6}
|
||||
>>> s1 | s2; # Union
|
||||
{1, 2, 3, 4, 5, 6}
|
||||
>>> s1 & s2; # Intersection
|
||||
{3, 4}
|
||||
>>> s1 - s2; # Difference
|
||||
{1, 2}
|
||||
>>> s1 < s1; # True subset
|
||||
False
|
||||
>>> {3, 1} < s1; # True subset
|
||||
True
|
||||
>>> s1 <= s1; # Subset
|
||||
True
|
||||
>>> {3, 1} <= s1; # Subset
|
||||
True
|
||||
>>> {3, 2, 4, 1} == s1; # Equality
|
||||
True
|
||||
>>> s1 == s2; # Equality
|
||||
False
|
||||
>>> 2 in s1; # Membership
|
||||
True
|
||||
>>> 10 not in s1; # Non-membership
|
||||
True
|
||||
>>> {1, 2, 3, 4, 5} > s1; # True superset
|
||||
True
|
||||
>>> {1, 2, 3, 4} > s1; # True superset
|
||||
False
|
||||
>>> {1, 2, 3, 4} >= s1; # Superset
|
||||
True
|
||||
>>> s1 ^ s2; # Symmetric difference
|
||||
{1, 2, 5, 6}
|
||||
>>> len(s1); # Cardinality
|
||||
4
|
||||
>>> s1.add(99); # Mutability
|
||||
>>> s1
|
||||
{99, 1, 2, 3, 4}
|
||||
>>> s1.discard(99); # Mutability
|
||||
>>> s1
|
||||
{1, 2, 3, 4}
|
||||
>>> s1 |= s2; # Mutability
|
||||
>>> s1
|
||||
{1, 2, 3, 4, 5, 6}
|
||||
>>> s1 -= s2; # Mutability
|
||||
>>> s1
|
||||
{1, 2}
|
||||
>>> s1 ^= s2; # Mutability
|
||||
>>> s1
|
||||
{1, 2, 3, 4, 5, 6}
|
||||
>>>
|
||||
56
Task/Set/REXX/set.rexx
Normal file
56
Task/Set/REXX/set.rexx
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
/*REXX program demonstrates some common SET functions. */
|
||||
truth.0='false'; truth.1='true' /*common names for truth table. */
|
||||
set.= /*order of sets isn't important. */
|
||||
|
||||
call setAdd 'prime',2 3 2 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
|
||||
call setSay 'prime' /*a small set of primes (numbers).*/
|
||||
|
||||
call setAdd 'emirp',97 97 89 83 79 73 71 67 61 59 53 47 43 41 37 31 29 23 19 17 13 11 7 5 3 2
|
||||
call setSay 'emirp' /*a small set of baclward primes. */
|
||||
|
||||
call setAdd 'happy',1 7 10 13 19 23 28 31 32 44 49 68 70 79 82 86 91 100 94 97 97 97 97 97
|
||||
call setSay 'happy' /*a small set of happy numbers. */
|
||||
|
||||
do j=11 to 100 by 10 /*see if PRIME contains some nums*/
|
||||
call setHas 'prime',j
|
||||
say ' prime contains' j":" truth.result
|
||||
end /*j*/
|
||||
|
||||
call setUnion 'prime','happy','eweion'; call setSay 'eweion'
|
||||
call setCommon 'prime','happy','common'; call setSay 'common'
|
||||
call setDiff 'prime','happy','diff' ; call setSay 'diff'
|
||||
call setSubset 'prime','happy' ; say ' prime is a subset of happy:' truth.result
|
||||
call setEqual 'prime','emirp' ; say ' prime is equal to emirp:' truth.result
|
||||
exit /*stick a fork in it, we're done.*/
|
||||
/*──────────────────────────────────subroutines─────────────────────────*/
|
||||
setHas: procedure expose set.; arg _ .,! .;return wordpos(!,set._)\==0
|
||||
setAdd: return set$('add' ,arg(1),arg(2))
|
||||
setDiff: return set$('diff' ,arg(1),arg(2),arg(3))
|
||||
setSay: return set$('say' ,arg(1),arg(2))
|
||||
setUnion: return set$('union' ,arg(1),arg(2),arg(3))
|
||||
setCommon: return set$('common',arg(1),arg(2),arg(3))
|
||||
setEqual: return set$('equal' ,arg(1),arg(2))
|
||||
setSubset: return set$('subSet',arg(1),arg(2))
|
||||
/*──────────────────────────────────set$ subroutine─────────────────────*/
|
||||
set$: procedure expose set.; arg $,_1,_2,_3; set_=set._1; t=_3; s=t; !=1
|
||||
if $=='SAY' then do; say '[set.'_1"]="set._1; return set._1; end
|
||||
if $=='UNION' then do
|
||||
call set$ 'add',_3,set._1
|
||||
call set$ 'add',_3,set._2
|
||||
return set._3
|
||||
end
|
||||
add=$=='ADD';common=$=='COMMON';diff=$=='DIFF';eq=$=='EQUAL';subset=$=='SUBSET'
|
||||
if common | diff | eq | subset then s=_2
|
||||
if add then do; set_=_2; t=_1; s=_1; end
|
||||
|
||||
do j=1 for words(set_); _=word(set_,j); has=wordpos(_,set.s)\==0
|
||||
if (add & \has) |,
|
||||
(common & has) |,
|
||||
(diff & \has) then set.t=space(set.t _)
|
||||
if (eq | subset) & \has then return 0
|
||||
end /*j*/
|
||||
|
||||
if subset then return 1
|
||||
if eq then if arg()>3 then return 1
|
||||
else return set$('equal',_2,_1,1)
|
||||
return set.t
|
||||
12
Task/Set/Racket/set.rkt
Normal file
12
Task/Set/Racket/set.rkt
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
#lang racket
|
||||
|
||||
(define A (set 1 2 3 4))
|
||||
(define B (set 3 4 5 6))
|
||||
(define C (set 4 5))
|
||||
|
||||
(set-union A B) ; gives (set 1 2 3 4 5 6)
|
||||
(set-intersect A B) ; gives (set 3 4)
|
||||
(set-subtract A B) ; gives (set 1 2)
|
||||
(set=? A B) ; gives #f
|
||||
(subset? C A) ; gives #f
|
||||
(subset? C B) ; gives #t
|
||||
43
Task/Set/Ruby/set.rb
Normal file
43
Task/Set/Ruby/set.rb
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
>> require 'set'
|
||||
=> true
|
||||
>> s1, s2 = Set[1, 2, 3, 4], [3, 4, 5, 6].to_set # different ways of creating a set
|
||||
=> [#<Set: {1, 2, 3, 4}>, #<Set: {5, 6, 3, 4}>]
|
||||
>> s1 | s2 # Union
|
||||
=> #<Set: {5, 6, 1, 2, 3, 4}>
|
||||
>> s1 & s2 # Intersection
|
||||
=> #<Set: {3, 4}>
|
||||
>> s1 - s2 # Difference
|
||||
=> #<Set: {1, 2}>
|
||||
>> s1.proper_subset?(s1) # Proper subset
|
||||
=> false
|
||||
>> Set[3, 1].proper_subset?(s1) # Proper subset
|
||||
=> true
|
||||
>> s1.subset?(s1) # Subset
|
||||
=> true
|
||||
>> Set[3, 1].subset?(s1) # Subset
|
||||
=> true
|
||||
>> Set[3, 2, 4, 1] == s1 # Equality
|
||||
=> true
|
||||
>> s1 == s2 # Equality
|
||||
=> false
|
||||
>> s1.include?(2) # Membership
|
||||
=> true
|
||||
>> Set[1, 2, 3, 4, 5].proper_superset?(s1) # Proper superset
|
||||
=> true
|
||||
>> Set[1, 2, 3, 4].proper_superset?(s1) # Proper superset
|
||||
=> false
|
||||
>> Set[1, 2, 3, 4].superset?(s1) # Superset
|
||||
=> true
|
||||
>> s1 ^ s2 # Symmetric difference
|
||||
=> #<Set: {5, 6, 1, 2}>
|
||||
>> s1.size # Cardinality
|
||||
=> 4
|
||||
>> s1 << 99 # Mutability (or s1.add(99) )
|
||||
=> #<Set: {99, 1, 2, 3, 4}>
|
||||
>> s1.delete(99) # Mutability
|
||||
=> #<Set: {1, 2, 3, 4}>
|
||||
>> s1.merge(s2) # Mutability
|
||||
=> #<Set: {5, 6, 1, 2, 3, 4}>
|
||||
>> s1.subtract(s2) # Mutability
|
||||
=> #<Set: {1, 2}>
|
||||
>>
|
||||
10
Task/Set/Scala/set.scala
Normal file
10
Task/Set/Scala/set.scala
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
object sets {
|
||||
val set1 = Set(1,2,3,4,5)
|
||||
val set2 = Set(3,5,7,9)
|
||||
println(set1 contains 3)
|
||||
println(set1 | set2)
|
||||
println(set1 & set2)
|
||||
println(set1 diff set2)
|
||||
println(set1 subsetOf set2)
|
||||
println(set1 == set2)
|
||||
}
|
||||
43
Task/Set/Scheme/set.ss
Normal file
43
Task/Set/Scheme/set.ss
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
(define (element? a lst)
|
||||
(and (not (null? lst))
|
||||
(or (eq? a (car lst))
|
||||
(element? a (cdr lst)))))
|
||||
|
||||
; util, not strictly needed
|
||||
(define (uniq lst)
|
||||
(if (null? lst) lst
|
||||
(let ((a (car lst)) (b (cdr lst)))
|
||||
(if (element? a b)
|
||||
(uniq b)
|
||||
(cons a (uniq b))))))
|
||||
|
||||
(define (intersection a b)
|
||||
(cond ((null? a) '())
|
||||
((null? b) '())
|
||||
(else
|
||||
(append (intersection (cdr a) b)
|
||||
(if (element? (car a) b)
|
||||
(list (car a))
|
||||
'())))))
|
||||
|
||||
(define (union a b)
|
||||
(if (null? a) b
|
||||
(union (cdr a)
|
||||
(if (element? (car a) b)
|
||||
b
|
||||
(cons (car a) b)))))
|
||||
|
||||
(define (diff a b) ; a - b
|
||||
(if (null? a) '()
|
||||
(if (element? (car a) b)
|
||||
(diff (cdr a) b)
|
||||
(cons (car a) (diff (cdr a) b)))))
|
||||
|
||||
(define (subset? a b) ; A ⊆ B
|
||||
(if (null? a) #t
|
||||
(and (element? (car a) b)
|
||||
(subset? (cdr a) b))))
|
||||
|
||||
(define (set-eq? a b)
|
||||
(and (subset? a b)
|
||||
(subset? b a)))
|
||||
26
Task/Set/Seed7/set.seed7
Normal file
26
Task/Set/Seed7/set.seed7
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
$ include "seed7_05.s7i";
|
||||
|
||||
const type: charSet is set of char;
|
||||
enable_output(charSet);
|
||||
|
||||
const proc: main is func
|
||||
local
|
||||
const charSet: A is {'A', 'B', 'C', 'D', 'E', 'F'};
|
||||
var charSet: B is charSet.value;
|
||||
var char: m is 'A';
|
||||
begin
|
||||
B := {'E', 'F', 'G', 'H', 'I', 'K'};
|
||||
incl(B, 'J'); # Add 'J' to set B
|
||||
excl(B, 'K'); # Remove 'K' from set B
|
||||
writeln("A: " <& A);
|
||||
writeln("B: " <& B);
|
||||
writeln("m: " <& m);
|
||||
writeln("m in A -- m is an element in A: " <& m in A);
|
||||
writeln("A | B -- union: " <& A | B);
|
||||
writeln("A & B -- intersection: " <& A & B);
|
||||
writeln("A - B -- difference: " <& A - B);
|
||||
writeln("A >< B -- symmetric difference: " <& A >< B);
|
||||
writeln("A <= A -- subset: " <& A <= A);
|
||||
writeln("A < A -- proper subset: " <& A < A);
|
||||
writeln("A = B -- equality: " <& A = B);
|
||||
end func;
|
||||
20
Task/Set/Smalltalk/set.st
Normal file
20
Task/Set/Smalltalk/set.st
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
#(1 2 3) asSet union: #(2 3 4) asSet.
|
||||
"a Set(1 2 3 4)"
|
||||
|
||||
#(1 2 3) asSet intersection: #(2 3 4) asSet.
|
||||
"a Set(2 3)"
|
||||
|
||||
#(1 2 3) asSet difference: #(2 3 4) asSet.
|
||||
"a Set(1)"
|
||||
|
||||
#(1 2 3) asSet includesAllOf: #(1 3) asSet.
|
||||
"true"
|
||||
|
||||
#(1 2 3) asSet includesAllOf: #(1 3 4) asSet.
|
||||
"false"
|
||||
|
||||
#(1 2 3) asSet = #(2 1 3) asSet.
|
||||
"true"
|
||||
|
||||
#(1 2 3) asSet = #(1 2 4) asSet.
|
||||
"false"
|
||||
21
Task/Set/Tcl/set.tcl
Normal file
21
Task/Set/Tcl/set.tcl
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
package require struct::set
|
||||
|
||||
# Many ways to build sets
|
||||
set s1 [list 1 2 3 4]
|
||||
set s2 {3 4 5 6}
|
||||
struct::set add s3 {2 3 4 3 2}; # $s3 will be proper set...
|
||||
set item 5
|
||||
|
||||
puts "union: [struct::set union $s1 $s2]"
|
||||
puts "intersection: [struct::set intersect $s1 $s2]"
|
||||
puts "difference: [struct::set difference $s1 $s2]"
|
||||
puts "membership predicate: [struct::set contains $s1 $item]"
|
||||
puts "subset predicate: [struct::set subsetof $s1 $s2]"; # NB: not strict subset test!
|
||||
puts "equality predicate: [struct::set equal $s1 $s2]"
|
||||
|
||||
# Adding an element to a set (note that we pass in the name of the variable holding the set):
|
||||
struct::set include s3 $item
|
||||
# Removing an element from a set:
|
||||
struct::set exclude s3 $item
|
||||
# Getting the cardinality:
|
||||
puts "cardinality: [struct::set size $s3]
|
||||
Loading…
Add table
Add a link
Reference in a new issue