Лабораторные 31 и 32

students/23K1302/23K1302-p31/pom.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         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>23K1302</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K1302-p31</artifactId>
+    <description>Задание 31</description>
+</project>

students/23K1302/23K1302-p31/src/main/java/ru/mirea/practice/s0000001/PROCS.txt

@@ -0,0 +1,4 @@
+2, Intel Pentium 4, 2.0, 256, 0.400, 664, 734
+5, Intel Itanium, 0.800, 96, 0.266, 365, 701
+6, AMD Athlon XP, 1.6, 256, 0.266, 701, 634
+1, IBM Power 4, 1.3, 16384, 0.400, 814, 1169

students/23K1302/23K1302-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 busSpeed;
+    int specInt;
+    int specFp;
+
+    public Processor(int key, String name, double clockSpeed, int cacheSize, double busSpeed, int specInt, int specFp) {
+        this.key = key;
+        this.name = name;
+        this.clockSpeed = clockSpeed;
+        this.cacheSize = cacheSize;
+        this.busSpeed = busSpeed;
+        this.specInt = specInt;
+        this.specFp = specFp;
+    }
+
+    @Override
+    public String toString() {
+        return key + "," + name + "," + clockSpeed + "," + cacheSize + "," + busSpeed + "," + specInt + "," + specFp;
+    }
+}

students/23K1302/23K1302-p31/src/main/java/ru/mirea/practice/s0000001/ProcessorTreeManager.java

@@ -0,0 +1,78 @@
+package ru.mirea.practice.s0000001;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Scanner;
+
+public class ProcessorTreeManager {
+    private static final String FILE_NAME = "PROCS.TXT";
+    private TwoThreeTree tree = new TwoThreeTree();
+
+    public void loadFromFile() throws IOException {
+        try (BufferedReader br = new BufferedReader(new FileReader(FILE_NAME))) {
+            String line;
+            while ((line = br.readLine()) != null) {
+                String[] parts = line.split(",");
+                int key = Integer.parseInt(parts[0]);
+                String name = parts[1];
+                double clockSpeed = Double.parseDouble(parts[2]);
+                int cacheSize = Integer.parseInt(parts[3]);
+                double busSpeed = Double.parseDouble(parts[4]);
+                int specInt = Integer.parseInt(parts[5]);
+                int specFp = Integer.parseInt(parts[6]);
+                tree.insert(new Processor(key, name, clockSpeed, cacheSize, busSpeed, specInt, specFp));
+            }
+        }
+    }
+
+
+    public void saveToFile() throws IOException {
+        try (BufferedWriter bw = new BufferedWriter(new FileWriter(FILE_NAME))) {
+            for (Processor p : tree.getAllRecords()) {
+                bw.write(p.toString());
+                bw.newLine();
+            }
+        }
+    }
+
+    public void run() throws IOException {
+        try (Scanner scanner = new Scanner(System.in)) { // Используем try-with-resources
+            while (true) {
+                System.out.print("Enter command: ");
+                String command = scanner.nextLine();
+                switch (command.charAt(0)) {
+                    case 'L':
+                        tree.printTree();
+                        break;
+                    case 'D':
+                        int deleteKey = Integer.parseInt(command.substring(2));
+                        tree.delete(deleteKey);
+                        break;
+                    case 'A':
+                        int addKey = Integer.parseInt(command.substring(2));
+                        Processor newProcessor = new Processor(addKey, "Default Name", 3.5, 8, 1600, 1000, 2000);
+                        tree.insert(newProcessor);
+                        break;
+                    case 'S':
+                        saveToFile();
+                        break;
+                    case 'E':
+                        return; // Автоматически закроет Scanner
+                    default:
+                        System.out.println("Invalid command");
+                        break;
+                }
+            }
+        }
+    }
+
+
+    public static void main(String[] args) throws IOException {
+        ProcessorTreeManager manager = new ProcessorTreeManager();
+        manager.loadFromFile();
+        manager.run();
+    }
+}

students/23K1302/23K1302-p31/src/main/java/ru/mirea/practice/s0000001/TwoThreeTree.java

@@ -0,0 +1,117 @@
+package ru.mirea.practice.s0000001;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+class TwoThreeTree {
+    private class Node {
+        boolean isLeaf;
+        List<Processor> keys = new ArrayList<>();
+        List<Node> children = new ArrayList<>();
+
+        Node(boolean isLeaf) {
+            this.isLeaf = isLeaf;
+        }
+    }
+
+    private Node root = new Node(true);
+
+    public void insert(Processor p) {
+        if (root.isLeaf && root.keys.size() < 2) {
+            root.keys.add(p);
+            root.keys.sort(Comparator.comparingInt(a -> a.key));
+        } else {
+            Node newRoot = insert(root, p);
+            if (newRoot != null) {
+                Node oldRoot = root;
+                root = new Node(false);
+                root.keys.add(newRoot.keys.get(0));
+                root.children.add(oldRoot);
+                root.children.add(newRoot);
+            }
+        }
+    }
+
+    private Node insert(Node node, Processor p) {
+        if (node.isLeaf) {
+            node.keys.add(p);
+            node.keys.sort(Comparator.comparingInt(a -> a.key));
+            if (node.keys.size() > 2) {
+                return split(node);
+            }
+            return null;
+        }
+
+        int idx = 0;
+        while (idx < node.keys.size() && p.key > node.keys.get(idx).key) {
+            idx++;
+        }
+        Node newChild = insert(node.children.get(idx), p);
+        if (newChild != null) {
+            node.keys.add(idx, newChild.keys.get(0));
+            node.children.add(idx + 1, newChild);
+            if (node.keys.size() > 2) {
+                return split(node);
+            }
+        }
+        return null;
+    }
+
+    private Node split(Node node) {
+        Node sibling = new Node(node.isLeaf);
+        sibling.keys.add(node.keys.remove(2));
+        if (!node.isLeaf) {
+            sibling.children.add(node.children.remove(2));
+            sibling.children.add(node.children.remove(2));
+        }
+        return sibling;
+    }
+
+    public void delete(int key) {
+        // пустота
+    }
+
+    public void printTree() {
+        Queue<Node> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                Node node = queue.poll();
+                if (node.isLeaf) {
+                    for (Processor p : node.keys) {
+                        System.out.print(p.key + " ");
+                    }
+                } else {
+                    for (int j = 0; j < node.keys.size(); j++) {
+                        System.out.print(node.keys.get(j).key + "-");
+                    }
+                    for (Node child : node.children) {
+                        queue.add(child);
+                    }
+                }
+                System.out.print(" | ");
+            }
+            System.out.println();
+        }
+    }
+
+    public List<Processor> getAllRecords() {
+        List<Processor> records = new ArrayList<>();
+        collectRecords(root, records);
+        return records;
+    }
+
+    private void collectRecords(Node node, List<Processor> records) {
+        if (node.isLeaf) {
+            records.addAll(node.keys);
+        } else {
+            for (Node child : node.children) {
+                collectRecords(child, records);
+            }
+        }
+    }
+}

students/23K1302/23K1302-p32/pom.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         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>23K1302</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K1302-p32</artifactId>
+    <description>Задание 32</description>
+</project>

students/23K1302/23K1302-p32/src/main/java/ru/mirea/practice/s0000001/JohnsonTrotter.java

@@ -0,0 +1,82 @@
+package ru.mirea.practice.s0000001;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class JohnsonTrotter {
+
+    private JohnsonTrotter() {
+        // dhtnsb
+    }
+
+    static class Element {
+        int value;
+        boolean direction;
+
+        Element(int value) {
+            this.value = value;
+            this.direction = false;
+        }
+    }
+
+    public static void main(String[] args) {
+        int n = 4;
+        generatePermutations(n);
+    }
+
+    public static void generatePermutations(int n) {
+        List<Element> elements = new ArrayList<>();
+        for (int i = 1; i <= n; i++) {
+            elements.add(new Element(i));
+        }
+
+        printPermutation(elements);
+
+        while (true) {
+            int largestMovableIndex = getLargestMovableIndex(elements);
+            if (largestMovableIndex == -1) {
+                break;
+            }
+
+            Element largestMovable = elements.get(largestMovableIndex);
+            int swapIndex = largestMovable.direction ? largestMovableIndex + 1 : largestMovableIndex - 1;
+            swap(elements, largestMovableIndex, swapIndex);
+
+            for (Element e : elements) {
+                if (e.value > largestMovable.value) {
+                    e.direction = !e.direction;
+                }
+            }
+
+            printPermutation(elements);
+        }
+    }
+
+    private static int getLargestMovableIndex(List<Element> elements) {
+        int largestMovableIndex = -1;
+        for (int i = 0; i < elements.size(); i++) {
+            Element current = elements.get(i);
+            int neighborIndex = current.direction ? i + 1 : i - 1;
+
+            if (neighborIndex >= 0 && neighborIndex < elements.size() && current.value > elements.get(neighborIndex).value) {
+                if (largestMovableIndex == -1 || current.value > elements.get(largestMovableIndex).value) {
+                    largestMovableIndex = i;
+                }
+            }
+        }
+        return largestMovableIndex;
+    }
+
+    private static void swap(List<Element> elements, int i, int j) {
+        Element temp = elements.get(i);
+        elements.set(i, elements.get(j));
+        elements.set(j, temp);
+    }
+
+    private static void printPermutation(List<Element> elements) {
+        for (Element e : elements) {
+            System.out.print(e.value + " ");
+        }
+        System.out.println();
+    }
+}

students/23K1302/pom.xml

@@ -45,5 +45,7 @@
         <module>23K1302-p29</module>
         <module>23K1302-p30.1</module>
         <module>23K1302-p30.2</module>
+        <module>23K1302-p31</module>
+        <module>23K1302-p32</module>
     </modules>
 </project>