From 604600a9e606cd41f66c10a5200ca3c50866d892 Mon Sep 17 00:00:00 2001
From: AndrewRedFox <90340969+AndrewRedFox@users.noreply.github.com>
Date: Mon, 14 Feb 2022 00:54:16 +0300
Subject: [PATCH 1/3] Task1

---
 src/main/java/BitSet.java     |  90 ++++++++++++++++++++++++++
 src/test/java/BitSetTest.java | 116 ++++++++++++++++++++++++++++++++++
 2 files changed, 206 insertions(+)
 create mode 100644 src/main/java/BitSet.java
 create mode 100644 src/test/java/BitSetTest.java

diff --git a/src/main/java/BitSet.java b/src/main/java/BitSet.java
new file mode 100644
index 0000000..bac105c
--- /dev/null
+++ b/src/main/java/BitSet.java
@@ -0,0 +1,90 @@
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.lang.String;
+
+public class BitSet<T> {
+
+    public int size;
+    private ArrayList<T> arr = new ArrayList<T>();
+
+    public BitSet(int size) {
+        this.size = size;
+    }
+
+    public void addElement(T el) {
+        if (!arr.contains(el) && arr.size() < size) {
+            arr.add(el);
+        }else{
+            throw new IndexOutOfBoundsException();
+        }
+    }
+
+    public void addElement(T[] el) {
+        for (int i = 0; i < el.length; i++) {
+            if (!arr.contains(el[i]) && arr.size() < size) {
+                arr.add(el[i]);
+            }else{
+                throw new IndexOutOfBoundsException();
+            }
+        }
+    }
+
+    public void delete(T el) {
+        arr.remove(el);
+    }
+
+    public void delete(T[] el) {
+        for (int i = 0; i < el.length; i++) {
+            arr.remove(el[i]);
+        }
+    }
+
+    public String toString() {
+        String str = "";
+        for (int i = 0; i < arr.size(); i++) {
+            str += arr.get(i) + " ";
+        }
+        return str.trim();
+    }
+
+    public T get(int index) {
+        return arr.get(index);
+    }
+
+    public boolean contain(T el) {
+        return arr.contains(el);
+    }
+
+    public BitSet<T> intersection(BitSet<T> other) {
+        BitSet<T> intersections = new BitSet<T>(this.arr.size() + other.arr.size());
+
+        for (int i = 0; i < size; i++) {
+            if (other.arr.contains(this.get(i))) {
+                intersections.arr.add(this.get(i));
+            }
+        }
+        return intersections;
+    }
+
+    public BitSet<T> association(BitSet<T> other) {
+        BitSet<T> associations = new BitSet<T>(this.arr.size() + other.arr.size());
+        associations.arr = this.arr;
+        for (int i = 0; i < other.arr.size(); i++) {
+            associations.addElement(other.get(i));
+        }
+        return associations;
+    }
+
+    public BitSet<T> addition(BitSet<T> other) {
+        BitSet<T> additions = new BitSet<T>(this.arr.size() + other.arr.size());
+        for (int i = 0; i < size; i++) {
+            if (!other.arr.contains(this.get(i))) {
+                additions.arr.add(this.get(i));
+            }
+        }
+        return additions;
+    }
+
+
+}
diff --git a/src/test/java/BitSetTest.java b/src/test/java/BitSetTest.java
new file mode 100644
index 0000000..b9543ca
--- /dev/null
+++ b/src/test/java/BitSetTest.java
@@ -0,0 +1,116 @@
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class BitSetTest {
+    @Test
+    public void testAddElement() {
+        BitSet<Integer> n = new BitSet<Integer>(3);
+        n.addElement(10);
+        n.addElement(28);
+        n.addElement(101);
+        String expected = "10 28 101";
+        assertEquals(expected, n.toString());
+    }
+
+    @Test
+    public void testAddArrayElement() {
+        BitSet<Integer> n = new BitSet<Integer>(5);
+        Integer[] mas = new Integer[]{10, 23, 96};
+        n.addElement(10);
+        n.addElement(28);
+        n.addElement(101);
+        n.addElement(mas);
+        String expected = "10 28 101 23 96";
+        assertEquals(expected, n.toString());
+    }
+
+    @Test
+    public void testDelete() {
+        BitSet<Integer> n = new BitSet<Integer>(3);
+        n.addElement(10);
+        n.addElement(28);
+        n.addElement(101);
+        n.delete(28);
+        String expected = "10 101";
+        assertEquals(expected, n.toString());
+    }
+
+    @Test
+    public void testDeleteArrayElement() {
+        BitSet<Integer> n = new BitSet<Integer>(5);
+        Integer[] mas = new Integer[]{10, 23, 96};
+        n.addElement(10);
+        n.addElement(28);
+        n.addElement(101);
+        n.addElement(mas);
+        n.delete(mas);
+        String expected = "28 101";
+        assertEquals(expected, n.toString());
+    }
+
+    @Test
+    public void testGet() {
+        BitSet<Integer> n = new BitSet<Integer>(3);
+        n.addElement(10);
+        n.addElement(28);
+        n.addElement(101);
+        Integer expected = 28;
+        assertEquals(expected, n.get(1));
+    }
+
+    @Test
+    public void testContain() {
+        BitSet<Integer> n = new BitSet<Integer>(3);
+        n.addElement(10);
+        n.addElement(28);
+        n.addElement(101);
+        boolean expected = true;
+        boolean expected2 = false;
+        assertEquals(expected, n.contain(101));
+        assertEquals(expected2, n.contain(1010));
+    }
+    @Test
+    public void testIntersection() {
+        BitSet<String> otherN = new BitSet<String>(2);
+        otherN.addElement("10");
+        otherN.addElement("36");
+
+        BitSet<String> n1 = new BitSet<String>(5);
+        n1.addElement("10");
+        n1.addElement("45");
+        n1.addElement("96");
+
+        String expected = "10";
+        assertEquals(expected, otherN.intersection(n1).toString());
+    }
+    @Test
+    public void testAssociation() {
+        BitSet<String> otherN = new BitSet<String>(2);
+        otherN.addElement("10");
+        otherN.addElement("36");
+
+        BitSet<String> n1 = new BitSet<String>(5);
+        n1.addElement("10");
+        n1.addElement("45");
+        n1.addElement("96");
+
+        String expected = "10 36 45 96";
+        assertEquals(expected, otherN.association(n1).toString());
+    }
+    @Test
+    public void testAddition() {
+        BitSet<String> otherN = new BitSet<String>(2);
+        otherN.addElement("10");
+        otherN.addElement("36");
+
+        BitSet<String> n1 = new BitSet<String>(5);
+        n1.addElement("10");
+        n1.addElement("45");
+        n1.addElement("96");
+
+        String expected = "36";
+        assertEquals(expected, otherN.addition(n1).toString());
+    }
+
+}

From a30a9b0dc6916f176ca8512084cbb785cba07e33 Mon Sep 17 00:00:00 2001
From: AndrewRedFox <90340969+AndrewRedFox@users.noreply.github.com>
Date: Thu, 17 Feb 2022 19:04:20 +0300
Subject: [PATCH 2/3] Task1

---
 src/main/java/BitSet.java     | 57 ++++++++++++++++++++++++++++++----
 src/test/java/BitSetTest.java | 58 +++++++++++++++++++----------------
 2 files changed, 82 insertions(+), 33 deletions(-)

diff --git a/src/main/java/BitSet.java b/src/main/java/BitSet.java
index bac105c..da7df52 100644
--- a/src/main/java/BitSet.java
+++ b/src/main/java/BitSet.java
@@ -2,20 +2,49 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.lang.String;
+import java.util.Objects;
 
 public class BitSet<T> {
 
-    public int size;
+    private int size;
     private ArrayList<T> arr = new ArrayList<T>();
 
     public BitSet(int size) {
+        setSize(size);
+    }
+
+    public BitSet(int size, T a, T b, T c) {
+        setSize(size);
+        arr.add(a);
+        arr.add(b);
+        arr.add(c);
+    }
+
+    public BitSet(int size, T a) {
+        setSize(size);
+        arr.add(a);
+    }
+
+    public BitSet(int size, T a, T b, T c, T d, T e) {
+        setSize(size);
+        arr.add(a);
+        arr.add(b);
+        arr.add(c);
+        arr.add(d);
+        arr.add(e);
+    }
+
+    public void setSize(int size) {
         this.size = size;
     }
+    public int getSize(){
+        return size;
+    }
 
     public void addElement(T el) {
         if (!arr.contains(el) && arr.size() < size) {
             arr.add(el);
-        }else{
+        } else if (arr.size() >= size) {
             throw new IndexOutOfBoundsException();
         }
     }
@@ -24,7 +53,7 @@ public void addElement(T[] el) {
         for (int i = 0; i < el.length; i++) {
             if (!arr.contains(el[i]) && arr.size() < size) {
                 arr.add(el[i]);
-            }else{
+            } else if (arr.size() >= size) {
                 throw new IndexOutOfBoundsException();
             }
         }
@@ -32,20 +61,22 @@ public void addElement(T[] el) {
 
     public void delete(T el) {
         arr.remove(el);
+        setSize(this.size - 1);
     }
 
     public void delete(T[] el) {
         for (int i = 0; i < el.length; i++) {
             arr.remove(el[i]);
         }
+        setSize(this.size - el.length);
     }
 
     public String toString() {
-        String str = "";
+        StringBuilder str = new StringBuilder();
         for (int i = 0; i < arr.size(); i++) {
-            str += arr.get(i) + " ";
+            str.append(arr.get(i) + " ");
         }
-        return str.trim();
+        return str.toString().trim();
     }
 
     public T get(int index) {
@@ -64,6 +95,7 @@ public BitSet<T> intersection(BitSet<T> other) {
                 intersections.arr.add(this.get(i));
             }
         }
+        intersections.setSize(intersections.arr.size());
         return intersections;
     }
 
@@ -73,6 +105,7 @@ public BitSet<T> association(BitSet<T> other) {
         for (int i = 0; i < other.arr.size(); i++) {
             associations.addElement(other.get(i));
         }
+        associations.setSize(associations.arr.size());
         return associations;
     }
 
@@ -83,8 +116,20 @@ public BitSet<T> addition(BitSet<T> other) {
                 additions.arr.add(this.get(i));
             }
         }
+        additions.setSize(additions.arr.size());
         return additions;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        BitSet<?> bitSet = (BitSet<?>) o;
+        return size == bitSet.size && Objects.equals(arr, bitSet.arr);
+    }
 
+    @Override
+    public int hashCode() {
+        return Objects.hash(size, arr);
+    }
 }
diff --git a/src/test/java/BitSetTest.java b/src/test/java/BitSetTest.java
index b9543ca..733f7ec 100644
--- a/src/test/java/BitSetTest.java
+++ b/src/test/java/BitSetTest.java
@@ -6,47 +6,49 @@ public class BitSetTest {
     @Test
     public void testAddElement() {
         BitSet<Integer> n = new BitSet<Integer>(3);
+        BitSet<Integer> expected = new BitSet<>(3, 10, 28, 101);
         n.addElement(10);
         n.addElement(28);
         n.addElement(101);
-        String expected = "10 28 101";
-        assertEquals(expected, n.toString());
+        assertEquals(expected, n);
     }
 
     @Test
     public void testAddArrayElement() {
         BitSet<Integer> n = new BitSet<Integer>(5);
+        BitSet<Integer> expected = new BitSet<>(5, 10, 28, 101,23,96);
         Integer[] mas = new Integer[]{10, 23, 96};
         n.addElement(10);
         n.addElement(28);
         n.addElement(101);
         n.addElement(mas);
-        String expected = "10 28 101 23 96";
-        assertEquals(expected, n.toString());
+        assertEquals(expected, n);
     }
 
     @Test
     public void testDelete() {
-        BitSet<Integer> n = new BitSet<Integer>(3);
+        BitSet<Integer> n = new BitSet<Integer>(4);
+        BitSet<Integer> expected = new BitSet<>(3, 10, 28, 56);
         n.addElement(10);
         n.addElement(28);
         n.addElement(101);
-        n.delete(28);
-        String expected = "10 101";
-        assertEquals(expected, n.toString());
+        n.addElement(56);
+        n.delete(101);
+        assertEquals(expected, n);
     }
 
     @Test
     public void testDeleteArrayElement() {
-        BitSet<Integer> n = new BitSet<Integer>(5);
+        BitSet<Integer> n = new BitSet<Integer>(6);
+        BitSet<Integer> expected = new BitSet<>(3, 28, 101,99);
         Integer[] mas = new Integer[]{10, 23, 96};
         n.addElement(10);
         n.addElement(28);
         n.addElement(101);
+        n.addElement(99);
         n.addElement(mas);
         n.delete(mas);
-        String expected = "28 101";
-        assertEquals(expected, n.toString());
+        assertEquals(expected, n);
     }
 
     @Test
@@ -70,47 +72,49 @@ public void testContain() {
         assertEquals(expected, n.contain(101));
         assertEquals(expected2, n.contain(1010));
     }
+
     @Test
     public void testIntersection() {
-        BitSet<String> otherN = new BitSet<String>(2);
-        otherN.addElement("10");
-        otherN.addElement("36");
+        BitSet<Integer> otherN = new BitSet<Integer>(2);
+        BitSet<Integer> expected = new BitSet<Integer>(1, 10);
+        otherN.addElement(10);
+        otherN.addElement(36);
 
-        BitSet<String> n1 = new BitSet<String>(5);
-        n1.addElement("10");
-        n1.addElement("45");
-        n1.addElement("96");
+        BitSet<Integer> n1 = new BitSet<Integer>(3);
+        n1.addElement(10);
+        n1.addElement(45);
+        n1.addElement(96);
 
-        String expected = "10";
-        assertEquals(expected, otherN.intersection(n1).toString());
+        assertEquals(expected, otherN.intersection(n1));
     }
+
     @Test
     public void testAssociation() {
         BitSet<String> otherN = new BitSet<String>(2);
+        BitSet<String> expected = new BitSet<>(3, "10","36","45");
         otherN.addElement("10");
         otherN.addElement("36");
 
-        BitSet<String> n1 = new BitSet<String>(5);
+        BitSet<String> n1 = new BitSet<String>(2);
         n1.addElement("10");
         n1.addElement("45");
-        n1.addElement("96");
 
-        String expected = "10 36 45 96";
-        assertEquals(expected, otherN.association(n1).toString());
+        assertEquals(expected, otherN.association(n1));
     }
+
     @Test
     public void testAddition() {
         BitSet<String> otherN = new BitSet<String>(2);
+        BitSet<String> expected = new BitSet<>(1, "36");
         otherN.addElement("10");
         otherN.addElement("36");
 
-        BitSet<String> n1 = new BitSet<String>(5);
+        BitSet<String> n1 = new BitSet<String>(3);
         n1.addElement("10");
         n1.addElement("45");
         n1.addElement("96");
 
-        String expected = "36";
-        assertEquals(expected, otherN.addition(n1).toString());
+        assertEquals(expected, otherN.addition(n1));
     }
 
 }

From 775869308e8a093e0e03ad9bd8ae81a8c8bfe2e1 Mon Sep 17 00:00:00 2001
From: AndrewRedFox <90340969+AndrewRedFox@users.noreply.github.com>
Date: Thu, 17 Feb 2022 19:06:11 +0300
Subject: [PATCH 3/3] Task1

---
 src/main/java/BitSet.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/java/BitSet.java b/src/main/java/BitSet.java
index da7df52..a29c974 100644
--- a/src/main/java/BitSet.java
+++ b/src/main/java/BitSet.java
@@ -37,7 +37,8 @@ public BitSet(int size, T a, T b, T c, T d, T e) {
     public void setSize(int size) {
         this.size = size;
     }
-    public int getSize(){
+
+    public int getSize() {
         return size;
     }
 
@@ -71,6 +72,7 @@ public void delete(T[] el) {
         setSize(this.size - el.length);
     }
 
+    @Override
     public String toString() {
         StringBuilder str = new StringBuilder();
         for (int i = 0; i < arr.size(); i++) {