Skip to content

BitSet ​

BitSet implementa un conjunto de bits compacto sobre una capacidad fija, respaldado por un array de palabras de 64 bits, con operaciones de conjunto.

Construcción ​

SintaxisDescripción
BitSet(n)Crea un conjunto de bits con capacidad para n bits, todos inicialmente en cero
BitSet.fromArray(arr)Crea un conjunto de bits con los bits de las posiciones en arr activados

fromArray requiere un argumento usize[]. Las posiciones de bits están indexadas desde 0 hasta n - 1.

Métodos ​

MétodoFirmaRetornoDescripción
set(index: usize, value?: boolean) => voidvoidActiva, desactiva o define condicionalmente el bit en index (por defecto: true)
flip(index: usize) => voidvoidAlterna el bit en index
get(index: usize) => booleanbooleanSi el bit en index está activado
count() => usizeusizeNúmero de bits activados
isEmpty() => booleanbooleanSi no hay bits activados
isSubset(other: BitSet) => booleanbooleanSi todo bit activado también está activado en other
isSuperset(other: BitSet) => booleanbooleanSi todo bit activado en other también está activado
union(other: BitSet) => BitSetBitSetConjunto de bits con todos los bits de ambos conjuntos
intersection(other: BitSet) => BitSetBitSetConjunto de bits con los bits activados en ambos
difference(other: BitSet) => BitSetBitSetConjunto de bits con bits activados aquí pero no en other
complement() => BitSetBitSetConjunto de bits con cada bit alternado sobre la capacidad
clear() => voidvoidLimpia todos los bits

union, intersection, difference y complement devuelven un BitSet nuevo propiedad del llamador; se libera automáticamente cuando la variable sale del ámbito.

Complejidad ​

OperaciónComplejidad de Tiempo
setO(1)
flipO(1)
getO(1)
countO(n), número de palabras de máquina
isEmptyO(n), número de palabras de máquina
isSubsetO(n), número de palabras de máquina
isSupersetO(n), número de palabras de máquina
unionO(n), número de palabras de máquina
intersectionO(n), número de palabras de máquina
differenceO(n), número de palabras de máquina
complementO(n), número de palabras de máquina
clearO(n), número de palabras de máquina

Ejemplos ​

Construcción ​

tyrus
import { BitSet } from "tyrus:algorithm";

const bs = BitSet(100);

set y get ​

tyrus
const bs = BitSet(100);

bs.set(5);
bs.set(10, true);
bs.set(3, false);

print(bs.get(5));   // true
print(bs.get(3));   // false
print(bs.get(10));  // true

flip ​

tyrus
const bs = BitSet(100);

bs.set(3);

print(bs.get(3));  // true

bs.flip(3);

print(bs.get(3));  // false

count e isEmpty ​

tyrus
const bs = BitSet(100);

print(bs.count());     // 0
print(bs.isEmpty());   // true

bs.set(1);
bs.set(2);

print(bs.count());    // 2
print(bs.isEmpty());  // false

isSubset y isSuperset ​

tyrus
const a = BitSet(100);
a.set(1);
a.set(3);

const b = BitSet(100);
b.set(1);
b.set(3);
b.set(5);

print(a.isSubset(b));    // true
print(b.isSuperset(a));  // true
print(b.isSubset(a));    // false

union, intersection y difference ​

tyrus
const a = BitSet(100);
a.set(1);
a.set(3);
a.set(5);

const b = BitSet(100);
b.set(3);
b.set(5);
b.set(7);

print(a.union(b).count());        // 4
print(a.intersection(b).count()); // 2
print(a.difference(b).count());   // 1

complement ​

tyrus
const bs = BitSet(100);
bs.set(3);
bs.set(5);
bs.set(7);

print(bs.complement().count());  // 97
print(bs.complement().get(1));   // true

fromArray ​

tyrus
const indexes: usize[] = [3, 5, 10];
const bs = BitSet.fromArray(indexes);

print(bs.count());  // 3
print(bs.get(10));  // true
print(bs.get(4));   // false

clear ​

tyrus
const bs = BitSet(100);
bs.set(1);
bs.set(2);

print(bs.isEmpty());  // false

bs.clear();

print(bs.isEmpty());  // true