2022-08-16 20:23:48 +03:00
|
|
|
module datatypes
|
|
|
|
|
2022-11-26 19:23:26 +03:00
|
|
|
pub struct Set[T] {
|
2022-08-16 20:23:48 +03:00
|
|
|
mut:
|
|
|
|
elements map[T]u8
|
|
|
|
}
|
|
|
|
|
|
|
|
// checks the element is exists.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (set Set[T]) exists(element T) bool {
|
2022-08-16 20:23:48 +03:00
|
|
|
return element in set.elements
|
|
|
|
}
|
|
|
|
|
|
|
|
// adds the element to set, if it is not present already.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (mut set Set[T]) add(element T) {
|
2022-08-16 20:23:48 +03:00
|
|
|
set.elements[element] = 1
|
|
|
|
}
|
|
|
|
|
|
|
|
// removes the element from set.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (mut set Set[T]) remove(element T) {
|
2022-08-16 20:23:48 +03:00
|
|
|
set.elements.delete(element)
|
|
|
|
}
|
|
|
|
|
|
|
|
// pick returns an arbitrary element of set, if set is not empty.
|
2022-11-28 11:24:47 +03:00
|
|
|
pub fn (set Set[T]) pick() !T {
|
2022-08-16 20:23:48 +03:00
|
|
|
for k, _ in set.elements {
|
|
|
|
return k
|
|
|
|
}
|
|
|
|
return error('Set is empty.')
|
|
|
|
}
|
|
|
|
|
|
|
|
// rest returns the set consisting of all elements except for the arbitrary element.
|
2022-11-28 11:24:47 +03:00
|
|
|
pub fn (mut set Set[T]) rest() ![]T {
|
|
|
|
element := set.pick()!
|
2022-08-16 20:23:48 +03:00
|
|
|
return set.elements.keys().filter(it != element)
|
|
|
|
}
|
|
|
|
|
|
|
|
// pop returns an arbitrary element and deleting it from set.
|
2022-11-28 11:24:47 +03:00
|
|
|
pub fn (mut set Set[T]) pop() !T {
|
|
|
|
element := set.pick()!
|
2022-08-16 20:23:48 +03:00
|
|
|
set.elements.delete(element)
|
|
|
|
return element
|
|
|
|
}
|
|
|
|
|
|
|
|
// delete all elements of set.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (mut set Set[T]) clear() {
|
2022-08-16 20:23:48 +03:00
|
|
|
set.elements = map[T]u8{}
|
|
|
|
}
|
|
|
|
|
2022-08-26 07:03:23 +03:00
|
|
|
// equal checks whether the two given sets are equal (i.e. contain all and only the same elements).
|
2022-12-02 10:22:48 +03:00
|
|
|
[deprecated: 'use set1[T] == set2[T] instead']
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (l Set[T]) equal(r Set[T]) bool {
|
2022-08-26 07:03:23 +03:00
|
|
|
return l == r
|
|
|
|
}
|
|
|
|
|
|
|
|
// == checks whether the two given sets are equal (i.e. contain all and only the same elements).
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (l Set[T]) == (r Set[T]) bool {
|
2022-08-16 20:23:48 +03:00
|
|
|
if l.elements.len != r.elements.len {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
for e, _ in r.elements {
|
|
|
|
if e !in l.elements {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2022-08-26 07:03:23 +03:00
|
|
|
// is_empty checks whether the set is empty or not.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (set Set[T]) is_empty() bool {
|
2022-08-16 20:23:48 +03:00
|
|
|
return set.size() == 0
|
|
|
|
}
|
|
|
|
|
|
|
|
// size returns the number of elements in the set.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (set Set[T]) size() int {
|
2022-08-16 20:23:48 +03:00
|
|
|
return set.elements.len
|
|
|
|
}
|
|
|
|
|
|
|
|
// copy returns a copy of all the elements in the set.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (set Set[T]) copy() Set[T] {
|
|
|
|
return Set[T]{
|
2022-08-16 20:23:48 +03:00
|
|
|
elements: set.elements.clone()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// add_all adds the whole `elements` array to the set
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (mut set Set[T]) add_all(elements []T) {
|
2022-08-16 20:23:48 +03:00
|
|
|
for element in elements {
|
|
|
|
set.add(element)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// @union returns the union of the two sets.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (l Set[T]) @union(r Set[T]) Set[T] {
|
2022-08-16 20:23:48 +03:00
|
|
|
mut set := l
|
|
|
|
for e, _ in r.elements {
|
|
|
|
set.add(e)
|
|
|
|
}
|
|
|
|
return set
|
|
|
|
}
|
|
|
|
|
|
|
|
// intersection returns the intersection of sets.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (l Set[T]) intersection(r Set[T]) Set[T] {
|
2022-08-16 20:23:48 +03:00
|
|
|
mut set := l
|
|
|
|
for e, _ in l.elements {
|
|
|
|
if !r.exists(e) {
|
|
|
|
set.remove(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for e, _ in r.elements {
|
|
|
|
if !l.exists(e) {
|
|
|
|
set.remove(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return set
|
|
|
|
}
|
|
|
|
|
|
|
|
// difference returns the difference of sets.
|
2022-12-02 10:22:48 +03:00
|
|
|
[deprecated: 'use set1[T] - set2[T] instead']
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (l Set[T]) difference(r Set[T]) Set[T] {
|
2022-08-26 07:03:23 +03:00
|
|
|
return l - r
|
|
|
|
}
|
|
|
|
|
|
|
|
// - returns the difference of sets.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (l Set[T]) - (r Set[T]) Set[T] {
|
2022-08-16 20:23:48 +03:00
|
|
|
mut set := l
|
|
|
|
for e, _ in l.elements {
|
|
|
|
if r.exists(e) {
|
|
|
|
set.remove(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return set
|
|
|
|
}
|
|
|
|
|
|
|
|
// subset returns true if the set `r` is a subset of the set `l`.
|
2022-11-26 19:23:26 +03:00
|
|
|
pub fn (l Set[T]) subset(r Set[T]) bool {
|
2022-08-16 20:23:48 +03:00
|
|
|
for e, _ in r.elements {
|
|
|
|
if e !in l.elements {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|