diff --git a/students/23K0364/23K0364-p31/pom.xml b/students/23K0364/23K0364-p31/pom.xml
new file mode 100644
index 000000000..83496a046
--- /dev/null
+++ b/students/23K0364/23K0364-p31/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>23K0364</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0364-p31</artifactId>
+    <description>31 задание</description>
+</project>
diff --git a/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/FileManager.java b/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/FileManager.java
new file mode 100644
index 000000000..194a3d8fe
--- /dev/null
+++ b/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/FileManager.java
@@ -0,0 +1,43 @@
+package ru.mirea.practice.s0000001;
+
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.util.List;
+import java.io.File;
+
+final class FileManager {
+    private FileManager() {
+        throw new UnsupportedOperationException("Utility class");
+    }
+
+    public static void loadFromFile(String filename, TwoThreeTree tree) throws IOException {
+        File file = new File(filename);
+        if (!file.exists()) {
+            throw new IOException("Файл не найден: " + filename);
+        }
+
+        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                String[] data = line.split(", ");
+                Processor processor = new Processor(Integer.parseInt(data[0]), data[1], Double.parseDouble(data[2]),
+                    Integer.parseInt(data[3]), Double.parseDouble(data[4]),
+                    Integer.parseInt(data[5]), Integer.parseInt(data[6]));
+                tree.insert(processor);
+            }
+        }
+    }
+
+    public static void saveToFile(String filename, TwoThreeTree tree) throws IOException {
+        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
+            List<Processor> processors = tree.toList();
+            for (Processor processor : processors) {
+                writer.write(processor.toString());
+                writer.newLine();
+            }
+        }
+    }
+}
diff --git a/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/Main.java b/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/Main.java
new file mode 100644
index 000000000..386e407b2
--- /dev/null
+++ b/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/Main.java
@@ -0,0 +1,60 @@
+package ru.mirea.practice.s0000001;
+
+import java.io.IOException;
+import java.util.Scanner;
+
+public abstract class Main {
+    private static TwoThreeTree tree = new TwoThreeTree();
+
+    public static void main(String[] args) {
+        try (Scanner scanner = new Scanner(System.in)) {
+            try {
+                FileManager.loadFromFile("/Users/viktoriapermakova/Desktop/PROCS.TXT", tree);
+                System.out.println("Данные загружены.");
+            } catch (IOException e) {
+                System.err.println("Ошибка загрузки данных: " + e.getMessage());
+            }
+
+            while (true) {
+                System.out.print("Введите команду (L, D n, A n, S, E): ");
+                String command = scanner.nextLine();
+
+                if ("L".equalsIgnoreCase(command)) {
+                    tree.printTree();
+                } else if (command.startsWith("D")) {
+                    try {
+                        int key = Integer.parseInt(command.split(" ")[1]);
+                        tree.delete(key);
+                        System.out.println("Запись с ключом " + key + " удалена.");
+                    } catch (Exception e) {
+                        System.err.println("Ошибка удаления: " + e.getMessage());
+                    }
+                } else if (command.startsWith("A")) {
+                    try {
+                        int key = Integer.parseInt(command.split(" ")[1]);
+                        System.out.print("Введите данные процессора (название, тактовая частота, кеш, частота шины, SPECint, SPECfp): ");
+                        String[] data = scanner.nextLine().split(", ");
+                        Processor processor = new Processor(key, data[0], Double.parseDouble(data[1]), Integer.parseInt(data[2]),
+                            Double.parseDouble(data[3]), Integer.parseInt(data[4]), Integer.parseInt(data[5]));
+                        tree.insert(processor);
+                        System.out.println("Запись добавлена: " + processor);
+                    } catch (Exception e) {
+                        System.err.println("Ошибка добавления: " + e.getMessage());
+                    }
+                } else if ("S".equalsIgnoreCase(command)) {
+                    try {
+                        FileManager.saveToFile("/Users/viktoriapermakova/Desktop/PROCS.TXT", tree);
+                        System.out.println("Данные сохранены в файл.");
+                    } catch (IOException e) {
+                        System.err.println("Ошибка сохранения данных: " + e.getMessage());
+                    }
+                } else if ("E".equalsIgnoreCase(command)) {
+                    break;
+                } else {
+                    System.out.println("Неизвестная команда.");
+                }
+            }
+        }
+    }
+}
+
diff --git a/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/Processor.java b/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/Processor.java
new file mode 100644
index 000000000..ddba9e3c9
--- /dev/null
+++ b/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/Processor.java
@@ -0,0 +1,26 @@
+package ru.mirea.practice.s0000001;
+
+class Processor {
+    int key;
+    String name;
+    double clockSpeed;
+    int cacheSize;
+    double busFrequency;
+    int specInt;
+    int specFp;
+
+    public Processor(int key, String name, double clockSpeed, int cacheSize, double busFrequency, int specInt, int specFp) {
+        this.key = key;
+        this.name = name;
+        this.clockSpeed = clockSpeed;
+        this.cacheSize = cacheSize;
+        this.busFrequency = busFrequency;
+        this.specInt = specInt;
+        this.specFp = specFp;
+    }
+
+    @Override
+    public String toString() {
+        return key + ", " + name + ", " + clockSpeed + ", " + cacheSize + ", " + busFrequency + ", " + specInt + ", " + specFp;
+    }
+}
diff --git a/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/TwoThreeTree.java b/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/TwoThreeTree.java
new file mode 100644
index 000000000..759402b24
--- /dev/null
+++ b/students/23K0364/23K0364-p31/src/main/java/ru/mirea/practice/s0000001/TwoThreeTree.java
@@ -0,0 +1,174 @@
+package ru.mirea.practice.s0000001;
+
+import java.util.List;
+import java.util.ArrayList;
+
+class TwoThreeTree {
+    class Node {
+        List<Integer> keys = new ArrayList<>();
+        List<Node> children = new ArrayList<>();
+        Processor processor;
+        boolean isLeaf;
+
+        Node(Processor processor) {
+            this.processor = processor;
+            this.keys.add(processor.key);
+            this.isLeaf = true;
+        }
+
+        Node(int key) {
+            this.keys.add(key);
+        }
+
+        @Override
+        public String toString() {
+            if (isLeaf) {
+                return String.valueOf(keys.get(0));
+            } else if (keys.size() == 1) {
+                return keys.get(0) + " -";
+            } else {
+                return keys.get(0) + " " + keys.get(1);
+            }
+        }
+    }
+
+    Node root;
+
+    public void insert(Processor processor) {
+        if (root == null) {
+            root = new Node(processor);
+        } else {
+            Node newRoot = insertRecursive(root, processor);
+            if (newRoot != null) {
+                Node oldRoot = root;
+                root = new Node(newRoot.keys.get(0));
+                root.children.add(oldRoot);
+                root.children.add(newRoot);
+                root.isLeaf = false;
+            }
+        }
+    }
+
+    private Node insertRecursive(Node node, Processor processor) {
+        if (node.isLeaf) {
+            node.keys.add(processor.key);
+            node.keys.sort(Integer::compareTo);
+
+            if (node.keys.size() > 2) {
+                return splitNode(node);
+            }
+            return null;
+        } else {
+            int key = processor.key;
+
+            Node child;
+            if (key < node.keys.get(0)) {
+                child = node.children.get(0);
+            } else if (node.keys.size() == 1 || key < node.keys.get(1)) {
+                child = node.children.get(1);
+            } else {
+                child = node.children.get(2);
+            }
+
+            Node newChild = insertRecursive(child, processor);
+            if (newChild != null) {
+                node.keys.add(newChild.keys.get(0));
+                node.keys.sort(Integer::compareTo);
+                node.children.add(node.children.indexOf(child) + 1, newChild);
+
+                if (node.keys.size() > 2) {
+                    return splitNode(node);
+                }
+            }
+            return null;
+        }
+    }
+
+    private Node splitNode(Node node) {
+        Node newNode = new Node(node.keys.get(2));
+        newNode.isLeaf = node.isLeaf;
+
+        if (!node.isLeaf) {
+            newNode.children.add(node.children.remove(2));
+            newNode.children.add(node.children.remove(2));
+        }
+
+        node.keys.remove(2);
+        return newNode;
+    }
+
+    public void printTree() {
+        if (root == null) {
+            System.out.println("Дерево пустое.");
+            return;
+        }
+        printTreeRecursively(root);
+    }
+
+    private void printTreeRecursively(Node node) {
+        if (node == null) {
+            return;
+        }
+        System.out.println(node);
+        for (Node child : node.children) {
+            printTreeRecursively(child);
+        }
+    }
+
+    public void delete(int key) {
+        root = deleteRecursive(root, key);
+    }
+
+    private Node deleteRecursive(Node node, int key) {
+        if (node == null) {
+            System.out.println("Запись с ключом " + key + " не найдена.");
+            return null;
+        }
+
+        if (node.isLeaf) {
+            if (node.keys.contains(key)) {
+                node.keys.remove(Integer.valueOf(key));
+                if (node.keys.isEmpty()) {
+                    return null;
+                }
+            } else {
+                System.out.println("Запись с ключом " + key + " не найдена.");
+            }
+            return node;
+        }
+
+        if (key < node.keys.get(0)) {
+            Node child = deleteRecursive(node.children.get(0), key);
+            node.children.set(0, child);
+        } else if (node.keys.size() == 1 || key < node.keys.get(1)) {
+            Node child = deleteRecursive(node.children.get(1), key);
+            node.children.set(1, child);
+        } else {
+            Node child = deleteRecursive(node.children.get(2), key);
+            node.children.set(2, child);
+        }
+        return node;
+    }
+
+    public List<Processor> toList() {
+        List<Processor> result = new ArrayList<>();
+        collectProcessors(root, result);
+        return result;
+    }
+
+    private void collectProcessors(Node node, List<Processor> result) {
+        if (node == null) {
+            return;
+        }
+
+        if (node.isLeaf) {
+            if (node.processor != null) {
+                result.add(node.processor);
+            }
+        }
+
+        for (Node child : node.children) {
+            collectProcessors(child, result);
+        }
+    }
+}
diff --git a/students/23K0364/23K0364-p32/pom.xml b/students/23K0364/23K0364-p32/pom.xml
new file mode 100644
index 000000000..0f776b35f
--- /dev/null
+++ b/students/23K0364/23K0364-p32/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>23K0364</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0364-p32</artifactId>
+    <description>32 задание</description>
+</project>
diff --git a/students/23K0364/23K0364-p32/src/main/java/ru/mirea/practice/s0000001/JohnsonTrotter.java b/students/23K0364/23K0364-p32/src/main/java/ru/mirea/practice/s0000001/JohnsonTrotter.java
new file mode 100644
index 000000000..13bf4da64
--- /dev/null
+++ b/students/23K0364/23K0364-p32/src/main/java/ru/mirea/practice/s0000001/JohnsonTrotter.java
@@ -0,0 +1,71 @@
+package ru.mirea.practice.s0000001;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class JohnsonTrotter {
+    private static final int LEFT = -1;
+
+    public static void generatePermutations(int n) {
+        List<Integer> permutation = new ArrayList<>();
+        List<Integer> directions = new ArrayList<>();
+        for (int i = 1; i <= n; i++) {
+            permutation.add(i);
+            directions.add(LEFT);
+        }
+
+        printPermutation(permutation);
+
+        while (true) {
+            int largestMobileIndex = -1;
+            int largestMobileValue = -1;
+
+            for (int i = 0; i < n; i++) {
+                int currentDirection = directions.get(i);
+                int neighborIndex = i + currentDirection;
+
+                if (neighborIndex >= 0 && neighborIndex < n && permutation.get(i) > permutation.get(neighborIndex)) {
+                    if (permutation.get(i) > largestMobileValue) {
+                        largestMobileValue = permutation.get(i);
+                        largestMobileIndex = i;
+                    }
+                }
+            }
+
+            if (largestMobileIndex == -1) {
+                break;
+            }
+
+            int newIndex = largestMobileIndex + directions.get(largestMobileIndex);
+            swap(permutation, largestMobileIndex, newIndex);
+            swap(directions, largestMobileIndex, newIndex);
+
+            for (int i = 0; i < n; i++) {
+                if (permutation.get(i) > largestMobileValue) {
+                    directions.set(i, directions.get(i) * -1);
+                }
+            }
+
+            printPermutation(permutation);
+        }
+    }
+
+    private static void swap(List<Integer> list, int i, int j) {
+        int temp = list.get(i);
+        list.set(i, list.get(j));
+        list.set(j, temp);
+    }
+
+    private static void printPermutation(List<Integer> permutation) {
+        for (int num : permutation) {
+            System.out.print(num + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        int n = 3;
+        generatePermutations(n);
+    }
+}
+
diff --git a/students/23K0364/pom.xml b/students/23K0364/pom.xml
index f1641c31f..1c3926b36 100644
--- a/students/23K0364/pom.xml
+++ b/students/23K0364/pom.xml
@@ -45,5 +45,7 @@
         <module>23K0364-p29</module>
         <module>23K0364-p30.1</module>
         <module>23K0364-p30.2</module>
+        <module>23K0364-p31</module>
+        <module>23K0364-p32</module>
     </modules>
 </project>