diff --git a/basics/src/main/java/ru/msu/vmk/NumberSample.java b/basics/src/main/java/ru/msu/vmk/NumberSample.java
index 9961ed3..cefc15a 100644
--- a/basics/src/main/java/ru/msu/vmk/NumberSample.java
+++ b/basics/src/main/java/ru/msu/vmk/NumberSample.java
@@ -1,11 +1,33 @@
 package ru.msu.vmk;
 
 import java.math.BigDecimal;
+import java.util.Arrays;
 
 public class NumberSample {
+
     public static BigDecimal[] split(BigDecimal amount, int n) {
         // разделить amount на n частей
         // если остается остаток, прибавить его к первому числу
-        return null;
+        var array = new BigDecimal[n];
+        //var k = amount.scale();
+        BigDecimal sum = BigDecimal.valueOf(0.0);
+        //var a = amount.divide(BigDecimal.valueOf(n), k,6);
+        var a = amount.divide(BigDecimal.valueOf(n));
+
+        for(int i = 1; i < n; ++i) {
+            array[i] = a;
+            sum = sum.add(array[i]);
+        }
+        array[0] = amount.subtract(sum);
+
+       /* var a1 = amount.divide(BigDecimal.valueOf(n));
+        var a0 = a1.add(amount.remainder(BigDecimal.valueOf(n)));
+        array[0] = a0;
+
+        for(int i = 1; i < n; ++i){
+            array[i] = a1;
+        }*/
+
+        return array;
     }
 }
diff --git a/collections/src/main/java/ru/msu/vmk/LibraryImpl.java b/collections/src/main/java/ru/msu/vmk/LibraryImpl.java
index 60162b9..8953ceb 100644
--- a/collections/src/main/java/ru/msu/vmk/LibraryImpl.java
+++ b/collections/src/main/java/ru/msu/vmk/LibraryImpl.java
@@ -1,25 +1,39 @@
 package ru.msu.vmk;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class LibraryImpl implements Library{
+    private final ArrayList<Book> library_available_books = new ArrayList<>();
+    private final Map<Book, String> map_borrow_books = new HashMap<>();
+
     @Override
     public void addNewBook(Book book) {
-
+      library_available_books.add(book);
     }
 
     @Override
     public void borrowBook(Book book, String student) {
-
+        if (library_available_books.contains(book)){
+            map_borrow_books.put(book, student);
+            library_available_books.remove(book);
+        }
+        else {System.out.println("Указанная книга отсутствует в библиотеке");}
     }
 
     @Override
     public void returnBook(Book book, String student) {
-
+        if (map_borrow_books.containsKey(book) && map_borrow_books.containsValue(student)){
+            map_borrow_books.remove(book, student);
+            library_available_books.add(book);
+        }
+        else {System.out.println("Указанная книга не из данной библиотеки либо некорректно указаны данные");}
     }
 
     @Override
-    public List<Book> findAvailableBooks() {
-        return null;
+    public List<Book> findAvailableBooks(){
+        return new ArrayList<>(library_available_books);
     }
 }
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..1d05e49 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,14 @@
 package ru.msu.vmk;
 
+import ru.msu.vmk.figures.Animal;
+import ru.msu.vmk.figures.Cat;
+import ru.msu.vmk.figures.Dog;
+import ru.msu.vmk.figures.Robot;
+import ru.msu.vmk.figures.Runnable;
+
 import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
 
 /**
  * По примеру класса {@link Money} реализовать класс Quantity:
@@ -13,11 +21,26 @@
  * <br/> - для проверки работы реализовать функцию main() или Unit-test
  */
 public class Quantity {
+
+    private BigDecimal amount;
+    private 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("unitOfMeasurement cannot be empty");
+        }
+        this.amount = amount.setScale(2, RoundingMode.HALF_EVEN);
+        this.unitOfMeasurement = unitOfMeasurement;
+    }
+
+    public Quantity(String amount, String unitOfMeasurement) {
+        this(new BigDecimal(amount), unitOfMeasurement);
     }
 
     /**
@@ -25,7 +48,7 @@ public Quantity(BigDecimal amount, String unitOfMeasurement) {
      * @return {@link Quantity#amount}
      */
     public BigDecimal getAmount() {
-        return null;
+        return amount;
     }
 
     /**
@@ -34,8 +57,10 @@ public BigDecimal getAmount() {
      * @param quantity прибавляемое значение
      * @return сумма чисел
      */
-    public Quantity add(Quantity quantity) throws Exception {
-        return null;
+    public Quantity add(Quantity quantity) {
+        validateUnitOfMeasurementAreEqual(quantity);
+        BigDecimal sum = this.amount.add(quantity.amount);
+        return new Quantity(sum, this.unitOfMeasurement);
     }
 
     /**
@@ -44,8 +69,10 @@ public Quantity add(Quantity quantity) throws Exception {
      * @param quantity вычитаемое значение
      * @return разность чисел
      */
-    public Quantity subtract(Quantity quantity) throws Exception {
-        return null;
+    public Quantity subtract(Quantity quantity) {
+        validateUnitOfMeasurementAreEqual(quantity);
+        BigDecimal result1 = this.amount.subtract(quantity.amount);
+        return new Quantity(result1, this.unitOfMeasurement);
     }
 
     /**
@@ -54,8 +81,10 @@ public Quantity subtract(Quantity quantity) throws Exception {
      * @param quantity множитель
      * @return произведение
      */
-    public Quantity multiply(Quantity quantity) throws Exception {
-        return null;
+    public Quantity multiply(Quantity quantity) {
+        validateUnitOfMeasurementAreEqual(quantity);
+        BigDecimal result2 = this.amount.multiply(quantity.amount);
+        return new Quantity(result2, this.unitOfMeasurement);
     }
 
     /**
@@ -64,17 +93,55 @@ public Quantity multiply(Quantity quantity) throws Exception {
      * @param quantity делитель
      * @return частное
      */
-    public Quantity divide(Quantity quantity) throws Exception {
-        return null;
+    public Quantity divide(Quantity quantity) {
+        validateUnitOfMeasurementAreEqual(quantity);
+        BigDecimal result3 = this.amount.divide(quantity.amount);
+        return new Quantity(result3, this.unitOfMeasurement);
     }
 
     /**
      * Деление amount на n равных частей
      * если остается остаток, он прибавляется к первому числу
+     *
      * @param n делитель
      * @return равные части числа
      */
+
     public Quantity[] divide(int n) throws Exception {
-        return null;
+        if (n<=0) {throw new IllegalArgumentException("Количество частей должно быть больше 0");
+        }
+        var array = new Quantity[n];
+        BigDecimal a = this.amount.divide(BigDecimal.valueOf(n), 2, RoundingMode.HALF_UP);
+        BigDecimal difference = this.amount.subtract(a.multiply(BigDecimal.valueOf(n)));
+
+        if (difference.compareTo(BigDecimal.ZERO) > 0){
+            BigDecimal a0 = this.amount.remainder(BigDecimal.valueOf(n));
+            BigDecimal a1 = this.amount.subtract(a0);
+            BigDecimal a2 = a1.divide(BigDecimal.valueOf(n));
+            array[0] = new Quantity(a2.add(a0), this.unitOfMeasurement);
+
+            for(int i = 1; i < n; ++i) {
+                array[i] = new Quantity(a2, this.unitOfMeasurement);
+            }
+        }
+        else {
+            for(int i = 0; i < n; ++i) {
+                array[i] = new Quantity(a, this.unitOfMeasurement);
+            }
+        }
+        return array;
+    }
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Quantity quantity1 = (Quantity) o;
+
+        return amount.equals(quantity1.amount) && unitOfMeasurement.equals(quantity1.unitOfMeasurement);
+    }
+    private void validateUnitOfMeasurementAreEqual(Quantity quantity) {
+        if (!this.unitOfMeasurement.equals(quantity.unitOfMeasurement)) {
+            throw new IllegalArgumentException("Единицы измерения не совпадают: " + this.unitOfMeasurement + " " + quantity.unitOfMeasurement);
+        }
     }
 }