Power set: Difference between revisions

Content added Content deleted
Line 810: Line 810:


import (
import (
"bytes"
"fmt"
"fmt"
"strconv"
"strconv"
Line 818: Line 819:
// element is an interface, allowing different kinds of elements to be
// element is an interface, allowing different kinds of elements to be
// implemented and stored in sets.
// implemented and stored in sets.
type element interface {
type elem interface {
// an element must be distinguishable from other elements to satisfy
// an element must be distinguishable from other elements to satisfy
// the mathematical definition of a set. a.eq(b) must give the same
// the mathematical definition of a set. a.eq(b) must give the same
// result as b.eq(a).
// result as b.eq(a).
eq(element) bool
Eq(element) bool
// String result is used only for printable output. Given a, b where
// String result is used only for printable output. Given a, b where
// a.eq(b), it is not required that a.String() == b.String().
// a.eq(b), it is not required that a.String() == b.String().
String() string
fmt.Stringer
}
}


// integer type satisfying element interface
// integer type satisfying element interface
type intEle int
type Int int


func (i intEle) eq(e element) bool {
func (i Int) Eq(e elem) bool {
if j, ok := e.(intEle); ok {
j, ok := e.(Int)
return i == j
return ok && i == j
}
⚫
return false
}
}


func (i intEle) String() string {
func (i Int) String() string {
return strconv.Itoa(int(i))
return strconv.Itoa(int(i))
}
}


// set type implemented as a simple list. methods will be added to
// a set is a slice of elem's. methods are added to implement
// make it satisfy the element interface, allowing sets of sets.
// the element interface, to allow nesting.
type set []element
type set []elem


// uniqueness of elements can be ensured by using add method
// uniqueness of elements can be ensured by using add method
func (s *set) addEle(e element) {
func (s *set) add(e elem) {
if !s.hasEle(e) {
if !s.has(e) {
*s = append(*s, e)
*s = append(*s, e)
}
}
}
}


func (s *set) hasEle(e element) bool {
func (s *set) has(e elem) bool {
for _, ex := range *s {
for _, ex := range *s {
if e.eq(ex) {
if e.Eq(ex) {
return true
return true
}
}
Line 862: Line 861:
}
}


// elem.Eq
// method to satify element interface
func (s set) eq(e element) bool {
func (s set) Eq(e elem) bool {
t, ok := e.(set)
t, ok := e.(set)
if !ok {
if !ok {
Line 872: Line 871:
}
}
for _, se := range s {
for _, se := range s {
if !t.hasEle(se) {
if !t.has(se) {
return false
return false
}
}
Line 879: Line 878:
}
}


// elem.String
// method to satify element interface
func (s set) String() string {
func (s set) String() string {
r := "{"
var buf bytes.Buffer
buf.WriteRune('{')
for _, e := range s {
for _, e := range s {
if len(r) > 1 {
if len(r) > 1 {
r += " "
buf.WriteRune(' ')
}
}
r += fmt.Sprint(e)
buf.WriteString(e.String())
}
}
return r + "}"
buf.WriteRune('}')
⚫
return buf.String()
}
}


Line 906: Line 907:
func main() {
func main() {
var s set
var s set
for _, i := range []intEle{1, 2, 2, 3, 4, 4, 4} {
for _, i := range []Int{1, 2, 2, 3, 4, 4, 4} {
s.addEle(i)
s.add(i)
}
}
fmt.Println(s)
fmt.Println(s)
Retrieved from "https://rosettacode.org/wiki/Power_set"