2018-10-10 18:03:03 -04:00
---
id: 587d8254367417b2b2512c6f
2021-02-06 04:42:36 +00:00
title: Perform a Subset Check on Two Sets of Data
2018-10-10 18:03:03 -04:00
challengeType: 1
2021-02-06 04:42:36 +00:00
forumTopicId: 301707
2021-01-13 03:31:00 +01:00
dashedName: perform-a-subset-check-on-two-sets-of-data
2018-10-10 18:03:03 -04:00
---
2020-12-16 00:37:30 -07:00
# --description--
2018-10-10 18:03:03 -04:00
2021-02-06 04:42:36 +00:00
In this exercise, we are going to perform a subset test on 2 sets of data. We will create a method on our `Set` data structure called `isSubsetOf` . This will compare the first set against the second, and if the first set is fully contained within the second, it will return `true` .
For example, if `setA = ['a','b']` and `setB = ['a','b','c','d']` , then `setA` is a subset of `setB` , so `setA.isSubsetOf(setB)` should return `true` .
2018-10-10 18:03:03 -04:00
2020-12-16 00:37:30 -07:00
# --hints--
2018-10-10 18:03:03 -04:00
2021-02-06 04:42:36 +00:00
Your `Set` class should have a `isSubsetOf` method.
2018-10-10 18:03:03 -04:00
2020-12-16 00:37:30 -07:00
```js
assert(
(function () {
var test = new Set();
2021-02-06 04:42:36 +00:00
return typeof test.isSubsetOf === 'function';
2020-12-16 00:37:30 -07:00
})()
);
```
2021-02-06 04:42:36 +00:00
The first Set() should be contained in the second Set
2018-10-10 18:03:03 -04:00
```js
2020-12-16 00:37:30 -07:00
assert(
(function () {
var setA = new Set();
var setB = new Set();
setA.add('a');
setB.add('b');
setB.add('c');
setB.add('a');
setB.add('d');
2021-02-06 04:42:36 +00:00
var aIsSubsetOfB = setA.isSubsetOf(setB);
return aIsSubsetOfB === true;
2020-12-16 00:37:30 -07:00
})()
);
```
2018-10-10 18:03:03 -04:00
2021-02-06 04:42:36 +00:00
`['a', 'b'].isSubsetOf(['a', 'b', 'c', 'd'])` should return `true`
2020-12-16 00:37:30 -07:00
```js
assert(
(function () {
var setA = new Set();
var setB = new Set();
setA.add('a');
setA.add('b');
setB.add('a');
setB.add('b');
setB.add('c');
setB.add('d');
2021-02-06 04:42:36 +00:00
var aIsSubsetOfB = setA.isSubsetOf(setB);
return aIsSubsetOfB === true;
2020-12-16 00:37:30 -07:00
})()
);
2018-10-10 18:03:03 -04:00
```
2021-02-06 04:42:36 +00:00
`['a', 'b', 'c'].isSubsetOf(['a', 'b'])` should return `false`
2018-10-10 18:03:03 -04:00
2020-12-16 00:37:30 -07:00
```js
assert(
(function () {
var setA = new Set();
var setB = new Set();
setA.add('a');
setA.add('b');
setA.add('c');
setB.add('a');
setB.add('b');
2021-02-06 04:42:36 +00:00
var aIsSubsetOfB = setA.isSubsetOf(setB);
return aIsSubsetOfB === false;
2020-12-16 00:37:30 -07:00
})()
);
```
2018-10-10 18:03:03 -04:00
2021-02-06 04:42:36 +00:00
`[].isSubsetOf([])` should return `true`
2018-10-10 18:03:03 -04:00
2020-12-16 00:37:30 -07:00
```js
assert(
(function () {
var setA = new Set();
var setB = new Set();
2021-02-06 04:42:36 +00:00
var aIsSubsetOfB = setA.isSubsetOf(setB);
return aIsSubsetOfB === true;
2020-12-16 00:37:30 -07:00
})()
);
```
2018-10-10 18:03:03 -04:00
2021-02-06 04:42:36 +00:00
`['a', 'b'].isSubsetOf(['c', 'd'])` should return `false`
2018-10-10 18:03:03 -04:00
```js
2020-12-16 00:37:30 -07:00
assert(
(function () {
var setA = new Set();
var setB = new Set();
setA.add('a');
setA.add('b');
setB.add('c');
setB.add('d');
2021-02-06 04:42:36 +00:00
var aIsSubsetOfB = setA.isSubsetOf(setB);
return aIsSubsetOfB === false;
2020-12-16 00:37:30 -07:00
})()
);
2018-10-10 18:03:03 -04:00
```
2020-08-13 17:24:35 +02:00
2021-01-13 03:31:00 +01:00
# --seed--
## --seed-contents--
```js
class Set {
constructor() {
// This will hold the set
this.dictionary = {};
this.length = 0;
}
// This method will check for the presence of an element and return true or false
has(element) {
return this.dictionary[element] !== undefined;
}
// This method will return all the values in the set
values() {
return Object.keys(this.dictionary);
}
// This method will add an element to the set
add(element) {
if (!this.has(element)) {
this.dictionary[element] = true;
this.length++;
return true;
}
return false;
}
// This method will remove an element from a set
remove(element) {
if (this.has(element)) {
delete this.dictionary[element];
this.length--;
return true;
}
return false;
}
// This method will return the size of the set
size() {
return this.length;
}
// This is our union method
union(set) {
const newSet = new Set();
this.values().forEach(value => {
newSet.add(value);
})
set.values().forEach(value => {
newSet.add(value);
})
return newSet;
}
// This is our intersection method
intersection(set) {
const newSet = new Set();
let largeSet;
let smallSet;
if (this.dictionary.length > set.length) {
largeSet = this;
smallSet = set;
} else {
largeSet = set;
smallSet = this;
}
smallSet.values().forEach(value => {
if (largeSet.dictionary[value]) {
newSet.add(value);
}
})
return newSet;
}
difference(set) {
const newSet = new Set();
this.values().forEach(value => {
if (!set.dictionary[value]) {
newSet.add(value);
}
})
return newSet;
}
// Only change code below this line
2021-02-06 04:42:36 +00:00
2021-01-13 03:31:00 +01:00
// Only change code above this line
}
```
2020-12-16 00:37:30 -07:00
# --solutions--
2021-01-13 03:31:00 +01:00
```js
class Set {
constructor() {
this.dictionary = {};
this.length = 0;
}
has(element) {
return this.dictionary[element] !== undefined;
}
values() {
return Object.keys(this.dictionary);
}
add(element) {
if (!this.has(element)) {
this.dictionary[element] = true;
this.length++;
return true;
}
return false;
}
remove(element) {
if (this.has(element)) {
delete this.dictionary[element];
this.length--;
return true;
}
return false;
}
size() {
return this.length;
}
union(set) {
const newSet = new Set();
this.values().forEach(value => {
newSet.add(value);
})
set.values().forEach(value => {
newSet.add(value);
})
return newSet;
}
intersection(set) {
const newSet = new Set();
let largeSet;
let smallSet;
if (this.dictionary.length > set.length) {
largeSet = this;
smallSet = set;
} else {
largeSet = set;
smallSet = this;
}
smallSet.values().forEach(value => {
if (largeSet.dictionary[value]) {
newSet.add(value);
}
})
return newSet;
}
difference(set) {
const newSet = new Set();
this.values().forEach(value => {
if (!set.dictionary[value]) {
newSet.add(value);
}
})
return newSet;
}
isSubsetOf(set) {
for(const value of this.values()){
if(!set.dictionary[value]) return false;
}
return true
}
}
```