L25

src/L25.java

@@ -0,0 +1,93 @@
+import classes.RealSet;
+import utils.BinNode;
+import utils.Queue;
+
+public class L25 extends Main {
+
+    public static RealSet clone(RealSet rs){
+        RealSet temp = new RealSet();
+        for (int i = 0; i < rs.size(); i++) {
+            temp.insert(rs.findBiggest());
+            rs.remove(rs.findBiggest());
+        }
+        RealSet clone = new RealSet();
+        for (int i = 0; i < temp.size(); i++) {
+            double biggest = temp.findBiggest();
+            rs.insert(biggest);
+            clone.insert(biggest);
+            temp.remove(biggest);
+        }
+        return clone;
+    }
+
+    public static RealSet buildNeg(RealSet rs){
+        RealSet findIfThereIsNegative = clone(rs);
+        boolean isThereNegative = false;
+        for (int i = 0; i < findIfThereIsNegative.size(); i++) {
+            double biggest = findIfThereIsNegative.findBiggest();
+            if (biggest < 0) {
+                isThereNegative = true;
+            }
+            findIfThereIsNegative.remove(biggest);
+        }
+        if (!isThereNegative) {
+            return new RealSet();
+        }
+
+        RealSet clone = clone(rs);
+        while (clone.findBiggest() > 0) {
+            clone.remove(clone.findBiggest());
+        }
+        return clone;
+    }
+
+    public static <T> void inOrder(BinNode<T> root) {
+        if (root != null) {
+            inOrder(root.getLeft());
+            System.out.print(root);
+            inOrder(root.getRight());
+        }
+    }
+
+    public static Queue<Integer> q2A(BinNode<Queue<Integer>> root){
+        return q2A(root, new Queue<>());
+    }
+
+    public static Queue<Integer> q2A(BinNode<Queue<Integer>> root, Queue<Integer> queue){
+        if (root != null) {
+            q2A(root.getLeft(), queue);
+            if (root.getValue().isEmpty()) {
+                queue.insert(0);
+            } else if (lengthQueue(root.getValue()) == 1) {
+                queue.insert(root.getValue().remove());
+            } else if (lengthQueue(root.getValue()) == 2) {
+                queue.insert(root.getValue().remove() + root.getValue().remove());
+            } else {
+                queue.insert(
+                        root.getValue().remove() +
+                                root.getValue().remove() +
+                                root.getValue().remove()
+                );
+            }
+            q2A(root.getRight(), queue);
+        }
+        return queue;
+    }
+
+    public static void main(String[] args) {
+        Queue<Integer> q1 = buildQueue(8,4,9,7);
+        Queue<Integer> q2 = buildQueue(1,8,1,2);
+        Queue<Integer> q3 = buildQueue(3,1);
+        Queue<Integer> q4 = new Queue<>();
+        Queue<Integer> q5 = buildQueue(2,9,4,1);
+
+        BinNode<Queue<Integer>> root = new BinNode<>(q1);
+        root.setRight(new BinNode<>(q2));
+        root.getRight().setLeft(new BinNode<>(q3));
+        root.getRight().setRight(new BinNode<>(q4));
+        root.getRight().getRight().setLeft(new BinNode<>(q5));
+
+        System.out.println(q2A(root));
+    }
+
+}

src/classes/Card.java

@@ -0,0 +1,4 @@
+package classes;
+
+public record Card(int value, int shape) {
+}

src/classes/Deck.java

@@ -0,0 +1,56 @@
+package classes;
+
+import utils.HelpCommands;
+import utils.Node;
+
+public class Deck {
+
+        private final Node<Card> deck1;
+        private final Node<Card> deck2;
+        private final Node<Card> deck3;
+        private final Node<Card> deck4;
+
+        private final Node<Card> deck5;
+
+        public Deck() {
+            deck1 = new Node<>(new Card(-1, -1));
+            deck2 = new Node<>(new Card(-1, -1));
+            deck3 = new Node<>(new Card(-1, -1));
+            deck4 = new Node<>(new Card(-1, -1));
+
+            deck5 = new Node<>(new Card(-1, -1));
+        }
+
+        private Node<Card> getDeckByShape(int shape){
+            return switch (shape){
+                case 1 -> deck1;
+                case 2 -> deck2;
+                case 3 -> deck3;
+                case 4 -> deck4;
+                default -> throw new IllegalStateException("Unexpected value: " + shape);
+            };
+        }
+
+        public void insert(Card card){
+            HelpCommands.setLast(getDeckByShape(card.shape()), card);
+        }
+
+        public boolean move(int shape){
+            if (HelpCommands.lenNodes(getDeckByShape(shape)) < 2) {
+                return false;
+            }
+            HelpCommands.setLast(deck5, HelpCommands.getLast(getDeckByShape(shape)));
+            return true;
+        }
+
+        public int sum(){
+            int sum = 0;
+            Node<Card> p = deck5;
+            while (p != null) {
+                sum += p.getValue().value();
+                p = p.getNext();
+            }
+            return sum;
+        }
+
+}

src/classes/RealSet.java

@@ -0,0 +1,43 @@
+package classes;
+
+import utils.HelpCommands;
+import utils.Node;
+
+public class RealSet {
+
+    private Node<Double> node;
+
+    public RealSet() {
+    }
+
+    public int size(){
+        return HelpCommands.lenNodes(node);
+    }
+
+    public void insert(double num){
+        if (node == null) {
+            node = new Node<>(num);
+        } else {
+            HelpCommands.setLast(node, num);
+        }
+    }
+
+    public void insert(double... numbers){
+        for (double num : numbers){
+            HelpCommands.setLast(node, num);
+        }
+    }
+
+    public void remove(double num){
+        node = HelpCommands.removeValue(node, num);
+    }
+
+    public double findBiggest(){
+        return HelpCommands.findMax(node, true);
+    }
+
+    @Override
+    public String toString() {
+        return node.toString();
+    }
+}

src/utils/HelpCommands.java

@@ -271,16 +271,24 @@ public static <T> Queue<T> copyQueue(Queue<T> queue) {
         return copy;
     }
 
-    /**
-     * @param n
-     * @param max
-     * @return a new queue with n nodes and a max value of param max
-     * @RuntimeComplexity O(param n)
-     */
-    public static Queue<Integer> buildQueue(int n, int max) {
-        Queue<Integer> queue = new Queue<>();
-        for (int i = 0; i < n; i++) {
-            queue.insert((int) (Math.random() * max));
+//    /**
+//     * @param n
+//     * @param max
+//     * @return a new queue with n nodes and a max value of param max
+//     * @RuntimeComplexity O(param n)
+//     */
+//    public static Queue<Integer> buildQueue(int n, int max) {
+//        Queue<Integer> queue = new Queue<>();
+//        for (int i = 0; i < n; i++) {
+//            queue.insert((int) (Math.random() * max));
+//        }
+//        return queue;
+//    }
+
+    public static <T> Queue<T> buildQueue(T... values) {
+        Queue<T> queue = new Queue<>();
+        for (T value : values){
+            queue.insert(value);
         }
         return queue;
     }
@@ -477,6 +485,15 @@ public static int findMax(Node<Integer> node) {
         return max;
     }
 
+    public static double findMax(Node<Double> node, boolean idk) {
+        double max = node.getValue();
+        while (node.getNext() != null) {
+            max = Math.max(max, node.getNext().getValue());
+            node = node.getNext();
+        }
+        return max;
+    }
+
     /**
      * @param node the node
      * @return the length of the node
@@ -571,12 +588,12 @@ public static <T> Node<T> removeValue(Node<T> node, T value) {
             node = node.getNext();
         }
         Node<T> p = node;
-        for (int i = 0; i < lenNodes(node); i++) {
-            if (p.getNext().getValue() == value) {
+        while (p.getNext() != null){
+            if (p.getNext().getValue().equals(value)) {
                 p.setNext(p.getNext().getNext());
-            } else {
-                p = p.getNext();
+                return node;
             }
+            p = p.getNext();
         }
         return node;
     }
@@ -592,6 +609,20 @@ public static <T> Node<T> setFirst(Node<T> node, T value) {
         return ret;
     }
 
+    public static <T> void setLast(Node<T> node, T value){
+        while (node.getNext() != null) {
+            node = node.getNext();
+        }
+        node.setNext(new Node<>(value));
+    }
+
+    public static <T> T getLast(Node<T> node){
+        while (node.getNext() != null) {
+            node = node.getNext();
+        }
+        return node.getValue();
+    }
+
     /**
      * @param fst the node to reverse
      * @return a reversed form of the given node