बिट के साथ बिटसेट को कैसे कार्यान्वित करें?

Question

मुझे गो में बिटसेट पैकेज नहीं मिला, इसलिए मैंने इसे लागू करने का प्रयास किया। मैं बिट्स को स्टोर करने के लिए uint64 की एक सरणी का उपयोग करना चाहता हूं।

मुझे uint64 सरणी आवंटित करने के लिए बिट्स की संख्या की आवश्यकता है। जावा के साथ, मैं एक कन्स्ट्रक्टर को परिभाषित कर सकता हूं जो पूर्णांक लेता है। जबकि गो कन्स्ट्रक्टर प्रदान नहीं करता है, जबकि उपयोगकर्ता बिटसेट 'ऑब्जेक्ट' को सही ढंग से कैसे प्रारंभ कर सकता है जब उपयोगकर्ता नया() कहता है?

Answer 1

bitSet एक निजी struct के रूप में घोषित करें:

type BitSet interface { 
    Has(pos int) bool 
    Add(pos int) bool 
    Len() int 
} 

इसके अलावा एक समारोह NewBitSet बेनकाब:

func NewBitSet(len int) BitSet { 
    return &bitSet{len, make(uint64, (len+7)/8) } 
} 

यह कैप्सूलीकरण के लिए एक जाओ तरीका है

type bitSet struct { 
    len int 
    array []uint64 
} 

इंटरफ़ेस BitSet बेनकाब : एक इंटरफ़ेस साझा करें, कार्यान्वयन नहीं।

Answer 2

संक्षिप्त उत्तर यह है कि जब आप new() पर कॉल करते हैं तो आप BitSet ऑब्जेक्ट को ठीक से प्रारंभ नहीं कर सकते हैं।

सबसे अच्छी बात यह है कि आप इसे कर सकते हैं ताकि आपका BitSet का शून्य मान मान्य हो। यह list.List, sync.Mutex, और big.Int जैसे प्रकार हैं। इस तरह आप जानते हैं कि क्लाइंट के लिए अमान्य मान प्राप्त करना असंभव है।

अगली सबसे अच्छी बात यह है कि आप एक कंसक्टर-जैसी फ़ंक्शन (इस मामले में NewBitSet नामित) बना सकते हैं और ग्राहकों को इसे कॉल करने की उम्मीद करते हैं।

Answer 3

यदि आप अपने डेटा को स्टोर करने के लिए [] uint64 टुकड़ा का उपयोग करते हैं, तो शून्य टुकड़ा खाली बिटसेट के रूप में कार्य कर सकता है। असल में एक नील स्लाइस में शामिल होने से आपके लिए एक नई सरणी आवंटित होती है, हालांकि भाषा विशिष्टता उस गारंटी की प्रतीत नहीं होती है। उस तरह के सेटअप के साथ, नया (बिटसेट) तत्काल उपयोग योग्य होगा। उदाहरण:

bitset.go:

package bitset 

const size = 64 

type bits uint64 

// BitSet is a set of bits that can be set, cleared and queried. 
type BitSet []bits 

// Set ensures that the given bit is set in the BitSet. 
func (s *BitSet) Set(i uint) { 
    if len(*s) < int(i/size+1) { 
     r := make([]bits, i/size+1) 
     copy(r, *s) 
     *s = r 
    } 
    (*s)[i/size] |= 1 << (i % size) 
} 

// Clear ensures that the given bit is cleared (not set) in the BitSet. 
func (s *BitSet) Clear(i uint) { 
    if len(*s) >= int(i/size+1) { 
     (*s)[i/size] &^= 1 << (i % size) 
    } 
} 

// IsSet returns true if the given bit is set, false if it is cleared. 
func (s *BitSet) IsSet(i uint) bool { 
    return (*s)[i/size]&(1<<(i%size)) != 0 
} 

bitset_test.go:

package bitset 

import "fmt" 

func ExampleBitSet() { 
    s := new(BitSet) 
    s.Set(13) 
    s.Set(45) 
    s.Clear(13) 
    fmt.Printf("s.IsSet(13) = %t; s.IsSet(45) = %t; s.IsSet(30) = %t\n", 
       s.IsSet(13), s.IsSet(45), s.IsSet(30)) 
    // Output: s.IsSet(13) = false; s.IsSet(45) = true; s.IsSet(30) = false 
}