diff --git a/basics/src/main/java/ru/msu/vmk/NumberSample.java b/basics/src/main/java/ru/msu/vmk/NumberSample.java
index 9961ed3..eb1ca04 100644
--- a/basics/src/main/java/ru/msu/vmk/NumberSample.java
+++ b/basics/src/main/java/ru/msu/vmk/NumberSample.java
@@ -1,11 +1,15 @@
 package ru.msu.vmk;
 
+import java.lang.reflect.Array;
 import java.math.BigDecimal;
+import java.util.Arrays;
 
 public class NumberSample {
+
     public static BigDecimal[] split(BigDecimal amount, int n) {
-        // разделить amount на n частей
-        // если остается остаток, прибавить его к первому числу
-        return null;
+        var result = amount.divide(new BigDecimal(n));
+        BigDecimal[] resArray = new BigDecimal[n];
+        Arrays.fill(resArray, result);
+        return resArray;
     }
 }
diff --git a/collections/src/main/java/ru/msu/vmk/Book.java b/collections/src/main/java/ru/msu/vmk/Book.java
index f2af0e5..26369e3 100644
--- a/collections/src/main/java/ru/msu/vmk/Book.java
+++ b/collections/src/main/java/ru/msu/vmk/Book.java
@@ -1,5 +1,7 @@
 package ru.msu.vmk;
 
+import java.util.Objects;
+
 public class Book {
     private String title;
 
@@ -10,4 +12,16 @@ public Book(String title){
     public String getTitle(){
         return title;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Book book)) return false;
+        return Objects.equals(getTitle(), book.getTitle());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getTitle());
+    }
 }
diff --git a/collections/src/main/java/ru/msu/vmk/LibraryImpl.java b/collections/src/main/java/ru/msu/vmk/LibraryImpl.java
index 60162b9..3fb70a1 100644
--- a/collections/src/main/java/ru/msu/vmk/LibraryImpl.java
+++ b/collections/src/main/java/ru/msu/vmk/LibraryImpl.java
@@ -1,25 +1,61 @@
 package ru.msu.vmk;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 public class LibraryImpl implements Library{
+
+    private Map<Book, String> borrowedBooks = new HashMap<>();
+    private Map<Book, Integer> availableBooks = new HashMap<>();
+
     @Override
     public void addNewBook(Book book) {
-
+        // The implementation below works only in case
+        // 1-to-1 relations between Student and Book. If one Student 1-to-many to Books
+        // Than we need some ID and record object
+        if(!availableBooks.containsKey(book)) {
+            availableBooks.putIfAbsent(book, 1);
+        } else {
+            int currentNumber = availableBooks.get(book);
+            availableBooks.put(book, ++currentNumber);
+        }
     }
 
     @Override
     public void borrowBook(Book book, String student) {
-
+        String borrower = borrowedBooks.get(book);
+        if (student.equals(borrower)) {
+            throw new IllegalArgumentException("The student is already a borrower");
+        } else {
+            int currentNumber = availableBooks.get(book);
+            availableBooks.put(book, --currentNumber);
+            borrowedBooks.put(book, student);
+        }
     }
 
     @Override
     public void returnBook(Book book, String student) {
-
+        String borrower = borrowedBooks.get(book);
+        if (borrower.isEmpty()) {
+            throw new IllegalArgumentException("The book from student has been already returned");
+        } else {
+            borrowedBooks.remove(book);
+            int currentNumber = availableBooks.get(book);
+            availableBooks.put(book, ++currentNumber);
+            borrowedBooks.put(book, student);
+        }
     }
 
     @Override
     public List<Book> findAvailableBooks() {
-        return null;
+        return availableBooks
+                .entrySet()
+                .stream()
+                .filter(en -> en.getValue() > 0)
+                .map(Map.Entry::getKey)
+                .collect(Collectors.toList());
     }
 }
diff --git a/object-oriented-programming/src/main/java/ru/msu/vmk/Quantity.java b/object-oriented-programming/src/main/java/ru/msu/vmk/Quantity.java
index 6c1810e..c0ba69a 100644
--- a/object-oriented-programming/src/main/java/ru/msu/vmk/Quantity.java
+++ b/object-oriented-programming/src/main/java/ru/msu/vmk/Quantity.java
@@ -1,6 +1,11 @@
 package ru.msu.vmk;
 
 import java.math.BigDecimal;
+import java.math.MathContext;
+import java.math.RoundingMode;
+import java.util.Arrays;
+import java.util.Objects;
+
 
 /**
  * По примеру класса {@link Money} реализовать класс Quantity:
@@ -13,11 +18,24 @@
  * <br/> - для проверки работы реализовать функцию main() или Unit-test
  */
 public class Quantity {
+
+    private final BigDecimal amount;
+    private final String unitOfMeasurement;
+
+
     /**
      * @param amount - сумма
      * @param unitOfMeasurement - единица измерения
      */
     public Quantity(BigDecimal amount, String unitOfMeasurement) {
+        if (amount == null) {
+            throw new IllegalArgumentException("amount cannot be null");
+        }
+        if (unitOfMeasurement == null || unitOfMeasurement.isBlank()) {
+            throw new IllegalArgumentException("currency cannot be empty");
+        }
+        this.amount = amount;
+        this.unitOfMeasurement = unitOfMeasurement;
     }
 
     /**
@@ -25,7 +43,7 @@ public Quantity(BigDecimal amount, String unitOfMeasurement) {
      * @return {@link Quantity#amount}
      */
     public BigDecimal getAmount() {
-        return null;
+        return this.amount;
     }
 
     /**
@@ -34,8 +52,9 @@ public BigDecimal getAmount() {
      * @param quantity прибавляемое значение
      * @return сумма чисел
      */
-    public Quantity add(Quantity quantity) throws Exception {
-        return null;
+    public Quantity add(Quantity quantity) throws IllegalArgumentException {
+        validateMeasuresAreEqual(quantity);
+        return new Quantity(this.amount.add(quantity.amount), this.unitOfMeasurement);
     }
 
     /**
@@ -44,8 +63,9 @@ public Quantity add(Quantity quantity) throws Exception {
      * @param quantity вычитаемое значение
      * @return разность чисел
      */
-    public Quantity subtract(Quantity quantity) throws Exception {
-        return null;
+    public Quantity subtract(Quantity quantity) throws IllegalArgumentException {
+        validateMeasuresAreEqual(quantity);
+        return new Quantity(this.amount.subtract(quantity.amount), this.unitOfMeasurement);
     }
 
     /**
@@ -54,8 +74,9 @@ public Quantity subtract(Quantity quantity) throws Exception {
      * @param quantity множитель
      * @return произведение
      */
-    public Quantity multiply(Quantity quantity) throws Exception {
-        return null;
+    public Quantity multiply(Quantity quantity) throws IllegalArgumentException {
+        validateMeasuresAreEqual(quantity);
+        return new Quantity(this.amount.multiply(quantity.amount, new MathContext(2, RoundingMode.HALF_UP)), this.unitOfMeasurement);
     }
 
     /**
@@ -64,8 +85,9 @@ public Quantity multiply(Quantity quantity) throws Exception {
      * @param quantity делитель
      * @return частное
      */
-    public Quantity divide(Quantity quantity) throws Exception {
-        return null;
+    public Quantity divide(Quantity quantity) throws IllegalArgumentException {
+        validateMeasuresAreEqual(quantity);
+        return new Quantity(this.amount.divide(quantity.amount), this.unitOfMeasurement);
     }
 
     /**
@@ -74,7 +96,43 @@ public Quantity divide(Quantity quantity) throws Exception {
      * @param n делитель
      * @return равные части числа
      */
-    public Quantity[] divide(int n) throws Exception {
-        return null;
+    public Quantity[] divide(int n) {
+        Quantity[] result = new Quantity[n];
+        int valueWithoutIntegralScale = 10;
+        if (amount.longValue() < valueWithoutIntegralScale) {
+            var devisionValue = amount.divide(new BigDecimal(n));
+            Arrays.fill(result, new Quantity(devisionValue, unitOfMeasurement));
+        } else {
+            var devisionValue = amount.divideAndRemainder(new BigDecimal(n));
+            Arrays.fill(result, new Quantity(devisionValue[0], unitOfMeasurement));
+            result[0] = (new Quantity(devisionValue[0].add(devisionValue[1]), unitOfMeasurement));
+        }
+        return result;
+    }
+
+    private void validateMeasuresAreEqual(Quantity quantity) {
+        if (!this.unitOfMeasurement.equals(quantity.unitOfMeasurement)) {
+            throw new IllegalArgumentException("Единицы измерения не совпадают: " + this.unitOfMeasurement + " " + quantity.unitOfMeasurement);
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Quantity quantity)) return false;
+        return Objects.equals(amount, quantity.amount) && Objects.equals(unitOfMeasurement, quantity.unitOfMeasurement);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(amount, unitOfMeasurement);
+    }
+
+    @Override
+    public String toString() {
+        return "Quantity{" +
+                "amount=" + amount +
+                ", unitOfMeasurement='" + unitOfMeasurement + '\'' +
+                '}';
     }
 }