//GenericArrayQueue
public class GenericArrayQueue<T> {
    private T[] queueArray;
    private int front;
    private int rear;
    private int maxSize;
    private int currentSize;

    @SuppressWarnings("unchecked")
    public GenericArrayQueue(int size) {
        maxSize = size;
        queueArray = (T[]) new Object[maxSize];
        front = 0;
        rear = -1;
        currentSize = 0;
    }

    public void enqueue(T value) {
        if (isFull()) {
            System.out.println("Queue is full.");
        } else {
            rear = (rear + 1) % maxSize;
            queueArray[rear] = value;
            currentSize++;
        }
    }

    public T dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        } else {
            T temp = queueArray[front];
            front = (front + 1) % maxSize;
            currentSize--;
            return temp;
        }
    }

    public T peek() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        } else {
            return queueArray[front];
        }
    }

    public boolean isEmpty() {
        return (currentSize == 0);
    }
    
    public boolean isFull() {
        return (currentSize == maxSize);
    }

    public int size() {
        return currentSize;
    }
}
//Node.java
public class Node<T> {
    T data;
    Node<T> next;

    public Node(T data) {
        this.data = data;
        this.next = null;
    }
}
//GenericLinkedListQueue
public class GenericLinkedListQueue<T> {
    private Node<T> front;
    private Node<T> rear;
    private int size;

    public GenericLinkedListQueue() {
        front = null;
        rear = null;
        size = 0;
    }

    public void enqueue(T value) {
        Node<T> newNode = new Node<>(value);
        if (isEmpty()) {
            front = newNode;
        } else {
            rear.next = newNode;
        }
        rear = newNode;
        size++;
    }

    public T dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        } else {
            T value = front.data;
            front = front.next;
            if (front == null) {
                rear = null;
            }
            size--;
            return value;
        }
    }

    public T peek() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        } else {
            return front.data;
        }
    }

    public boolean isEmpty() {
        return (size == 0);
    }

    public int size() {
        return size;
    }
}
//Main
public class Main {
    public static void main(String[] args) {
        // Array-based queue
        GenericArrayQueue<Integer> intArrayQueue = new GenericArrayQueue<>(10);
        intArrayQueue.enqueue(1);
        intArrayQueue.enqueue(2);
        System.out.println(intArrayQueue.dequeue());  // Output: 1
        System.out.println(intArrayQueue.peek()); // Output: 2

        GenericArrayQueue<Double> doubleArrayQueue = new GenericArrayQueue<>(10);
        doubleArrayQueue.enqueue(1.1);
        doubleArrayQueue.enqueue(2.2);
        System.out.println(doubleArrayQueue.dequeue());  // Output: 1.1
        System.out.println(doubleArrayQueue.peek()); // Output: 2.2

        GenericArrayQueue<String> stringArrayQueue = new GenericArrayQueue<>(10);
        stringArrayQueue.enqueue("Hello");
        stringArrayQueue.enqueue("World");
        System.out.println(stringArrayQueue.dequeue());  // Output: Hello
        System.out.println(stringArrayQueue.peek()); // Output: World

        // Linked list-based queue
        GenericLinkedListQueue<Integer> intLinkedListQueue = new GenericLinkedListQueue<>();
        intLinkedListQueue.enqueue(1);
        intLinkedListQueue.enqueue(2);
        System.out.println(intLinkedListQueue.dequeue());  // Output: 1
        System.out.println(intLinkedListQueue.peek()); // Output: 2

        GenericLinkedListQueue<Double> doubleLinkedListQueue = new GenericLinkedListQueue<>();
        doubleLinkedListQueue.enqueue(1.1);
        doubleLinkedListQueue.enqueue(2.2);
        System.out.println(doubleLinkedListQueue.dequeue());  // Output: 1.1
        System.out.println(doubleLinkedListQueue.peek()); // Output: 2.2

        GenericLinkedListQueue<String> stringLinkedListQueue = new GenericLinkedListQueue<>();
        stringLinkedListQueue.enqueue("Hello");
        stringLinkedListQueue.enqueue("World");
        System.out.println(stringLinkedListQueue.dequeue());  // Output: Hello
        System.out.println(stringLinkedListQueue.peek()); // Output: World
    }
}

import java.util.Scanner;

class Node<T> {
    T data;
    Node<T> next;

    public Node(T data) {
        this.data = data;
        this.next = null;
    }
}

class GenericStackArray<T> {
    private T[] stackArray;
    private int top;
    private int maxSize;

    @SuppressWarnings("unchecked")
    public GenericStackArray(int size) {
        this.maxSize = size;
        this.stackArray = (T[]) new Object[maxSize];
        this.top = -1;
    }

    public void push(T item) {
        if (top < maxSize - 1) {
            stackArray[++top] = item;
        } else {
            System.out.println("Stack Overflow");
        }
    }

    public T pop() {
        if (top >= 0) {
            return stackArray[top--];
        } else {
            System.out.println("Stack Underflow");
            return null;
        }
    }
public T peek() {
        if (top == -1) {
            System.out.println("Stack is empty.");
            return null;
        } else {
            return stackArray[top];
        }
    }

    public boolean isEmpty() {
        return top == -1;
    }
}

class GenericStackLinkedList<T> {
    private Node<T> top;

    public GenericStackLinkedList() {
        this.top = null;
    }

    public void push(T item) {
        Node<T> newNode = new Node<>(item);
        newNode.next = top;
        top = newNode;
    }

    public T pop() {
        if (top == null) {
            System.out.println("Stack Underflow");
            return null;
        }
        T data = top.data;
        top = top.next;
        return data;
    }
public T peek() {
        if (top == null) {
            System.out.println("Stack is empty.");
            return null;
        } else {
            return top.data;
        }
    }
    public boolean isEmpty() {
        return top == null;
    }
}

public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("ARRAY....");
        GenericStackArray<Integer> intArrayStack = new GenericStackArray<>(10);
        intArrayStack.push(1);
        intArrayStack.push(2);
        System.out.println(intArrayStack.pop());  // Output: 2
        System.out.println(intArrayStack.peek()); // Output: 1

        GenericStackArray<Double> doubleArrayStack = new GenericStackArray<>(10);
        doubleArrayStack.push(1.1);
        doubleArrayStack.push(2.2);
        System.out.println(doubleArrayStack.pop());  // Output: 2.2
        System.out.println(doubleArrayStack.peek()); // Output: 1.1

        GenericStackArray<String> stringArrayStack = new GenericStackArray<>(10);
        stringArrayStack.push("Hello");
        stringArrayStack.push("World");
        System.out.println(stringArrayStack.pop());  // Output: World
        System.out.println(stringArrayStack.peek()); // Output: Hello

System.out.println("\nLINKED LIST....");
        // Linked list-based stack
        GenericStackLinkedList<Integer> intLinkedListStack = new GenericStackLinkedList<>();
        intLinkedListStack.push(1);
        intLinkedListStack.push(2);
        System.out.println(intLinkedListStack.pop());  // Output: 2
        System.out.println(intLinkedListStack.peek()); // Output: 1

        GenericStackLinkedList<Double> doubleLinkedListStack = new GenericStackLinkedList<>();
        doubleLinkedListStack.push(1.1);
        doubleLinkedListStack.push(2.2);
        System.out.println(doubleLinkedListStack.pop());  // Output: 2.2
        System.out.println(doubleLinkedListStack.peek()); // Output: 1.1

        GenericStackLinkedList<String> stringLinkedListStack = new GenericStackLinkedList<>();
        stringLinkedListStack.push("Hello");
        stringLinkedListStack.push("World");
        System.out.println(stringLinkedListStack.pop());  // Output: World
        System.out.println(stringLinkedListStack.peek()); // Output: Hello
}
}

const saveUserData = async (req, res, next) => {
  try {
    if (!Array.isArray(req.body.users)) {
      return res.status(400).json({ message: 'Invalid input format' });
    }

    const results = [];
    const errors = [];

    for (const user of req.body.users) {
      try {
        const saveUser = new saveuser({
          email: user.email,
          password: user.password,
        });

        const savedUser = await saveUser.save();
        const userID = savedUser._id;

        const saveDetail = new saveUserDetails({
          user_id: userID,
          name: user.name,
          phone: user.phone,
          country: user.country,
          file: user.file.filename,
        });

        const savedDetail = await saveDetail.save();

        results.push({
          status: 'success',
          user: savedUser,
          details: savedDetail,
        });
      } catch (error) {
        if (user.file && user.file.path && fs.existsSync(user.file.path)) {
          fs.unlinkSync(user.file.path);
        }
        if (error.name === 'ValidationError') {
          const validationError = {};
          for (const key in error.errors) {
            validationError[key] = error.errors[key].message;
          }
          errors.push({
            user: user,
            error: validationError,
          });
        } else {
          errors.push({
            user: user,
            error: 'Server Error',
          });
        }
      }
    }

    if (errors.length > 0) {
      return res.status(207).json({ results, errors });
    }

    res.status(200).json({ results });
  } catch (error) {
    res.status(500).json({
      message: 'Server Error',
    });
  }
};

//ReverseStringLambda
public class ReverseStringLambda {
    @FunctionalInterface
    interface StringReverser {
        String reverse(String str);
    }
    public static void main(String[] args) {
        StringReverser reverser = (str) -> new StringBuilder(str).reverse().toString();
        String example = "Hello, World!";
        String reversed = reverser.reverse(example);
        System.out.println("Original: " + example);
        System.out.println("Reversed: " + reversed);
    }
}

public class PiLambdaExpression{
    @FunctionalInterface
    interface PiValue{
        double getPi();
    }
    public static void main(String[] args) {
        PiValue pi = () -> Math.PI;
        double p= pi.getPi();
        System.out.println("The value of Pi is: " + p);
    }
}

//BoundedType
public class BoundedArithematic<T extends Number> {
    public double add(T a, T b) {
        return a.doubleValue() + b.doubleValue();
    }
    public double subtract(T a, T b) {
        return a.doubleValue() - b.doubleValue();
    }
    public double multiply(T a, T b) {
        return a.doubleValue() * b.doubleValue();
    }	
   public double divide(T a, T b) {
        if (b.doubleValue() == 0) {
            throw new ArithmeticException("Division by zero is not allowed.");
        }
        return a.doubleValue() / b.doubleValue();
    }
    public static void main(String[] args) {
        BoundedArithematic<Number> calculator = new BoundedArithematic<>();
        Integer a = 10;
        Integer b = 5;
        System.out.println("Addition: " + calculator.add(a, b));
        System.out.println("Subtraction: " + calculator.subtract(a, b));
        System.out.println("Multiplication: " + calculator.multiply(a, b));
        System.out.println("Division: " + calculator.divide(a, b));
    }
}

//Wildcard Arguments
public class MagicBox<T> {
    private T item;

    public void addItem(T item) {
        this.item = item;
        System.out.println("Added item to the magic box: " + item);
    }

    public T getItem() {
                return item;
    }

    public void processBox(MagicBox<? super Integer> box) {
        System.out.println("Items in the box are processed["+box.getItem()+"]"); 
    }

    public static void main(String[] args) {
        
        MagicBox<Integer> integerBox = new MagicBox<>();
        integerBox.addItem(23);
        		
		MagicBox<String> stringBox = new MagicBox<>();
        stringBox.addItem("Shreya");
        	
		
        MagicBox<Boolean> booleanBox = new MagicBox<>();
        booleanBox.addItem(false);
        
		MagicBox<Object> dobubleBox = new MagicBox<>();
        dobubleBox.addItem(23.43);
		
		integerBox.processBox(integerBox);
		dobubleBox.processBox(dobubleBox);
		
		
		
        
    }
}

class AVLNode {
    int key;
    int height;
    AVLNode left;
    AVLNode right;

    public AVLNode(int key) {
        this.key = key;
        this.height = 1;
    }
}

public class AVLTree {
    private AVLNode root;

    public AVLTree() {
        root = null;
    }

    // Insert a key into the AVL tree
    public void insert(int key) {
        root = insertRec(root, key);
    }

    // Helper method to recursively insert a key into the AVL tree
    private AVLNode insertRec(AVLNode node, int key) {
        if (node == null)
            return new AVLNode(key);

        if (key < node.key)
            node.left = insertRec(node.left, key);
        else if (key > node.key)
            node.right = insertRec(node.right, key);
        else // Duplicate keys are not allowed
            return node;

        // Update height of this node
        node.height = 1 + Math.max(height(node.left), height(node.right));

        // Get balance factor and perform rotations if needed
        int balance = getBalance(node);

        // Left Left Case
        if (balance > 1 && key < node.left.key)
            return rightRotate(node);

        // Right Right Case
        if (balance < -1 && key > node.right.key)
            return leftRotate(node);

        // Left Right Case
        if (balance > 1 && key > node.left.key) {
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }

        // Right Left Case
        if (balance < -1 && key < node.right.key) {
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }

        return node;
    }

    // Perform right rotation
    private AVLNode rightRotate(AVLNode y) {
        AVLNode x = y.left;
        AVLNode T2 = x.right;

        // Perform rotation
        x.right = y;
        y.left = T2;

        // Update heights
        y.height = Math.max(height(y.left), height(y.right)) + 1;
        x.height = Math.max(height(x.left), height(x.right)) + 1;

        return x;
    }

    // Perform left rotation
    private AVLNode leftRotate(AVLNode x) {
        AVLNode y = x.right;
        AVLNode T2 = y.left;

        // Perform rotation
        y.left = x;
        x.right = T2;

        // Update heights
        x.height = Math.max(height(x.left), height(x.right)) + 1;
        y.height = Math.max(height(y.left), height(y.right)) + 1;

        return y;
    }

    // Get height of a node
    private int height(AVLNode node) {
        if (node == null)
            return 0;
        return node.height;
    }

    // Get balance factor of a node
    private int getBalance(AVLNode node) {
        if (node == null)
            return 0;
        return height(node.left) - height(node.right);
    }

    // Find the inorder successor
    private AVLNode minValueNode(AVLNode node) {
        AVLNode current = node;
        while (current.left != null)
            current = current.left;
        return current;
    }

    // Delete a key from the AVL tree
    public void delete(int key) {
        root = deleteRec(root, key);
    }

    // Helper method to recursively delete a key from the AVL tree
    private AVLNode deleteRec(AVLNode root, int key) {
        if (root == null)
            return root;

        if (key < root.key)
            root.left = deleteRec(root.left, key);
        else if (key > root.key)
            root.right = deleteRec(root.right, key);
        else {
            // Node to be deleted found

            // Case 1: Node with one child or no child
            if (root.left == null || root.right == null) {
                AVLNode temp = null;
                if (root.left != null)
                    temp = root.left;
                else
                    temp = root.right;

                // No child case
                if (temp == null) {
                    temp = root;
                    root = null;
                } else // One child case
                    root = temp; // Copy the contents of the non-empty child

                temp = null;
            } else {
                // Case 2: Node with two children
                AVLNode temp = minValueNode(root.right);
                root.key = temp.key;
                root.right = deleteRec(root.right, temp.key);
            }
        }

        // If the tree had only one node then return
        if (root == null)
            return root;

        // Update height of the current node
        root.height = 1 + Math.max(height(root.left), height(root.right));

        // Get balance factor and perform rotations if needed
        int balance = getBalance(root);

        // Left Left Case
        if (balance > 1 && getBalance(root.left) >= 0)
            return rightRotate(root);

        // Left Right Case
        if (balance > 1 && getBalance(root.left) < 0) {
            root.left = leftRotate(root.left);
            return rightRotate(root);
        }

        // Right Right Case
        if (balance < -1 && getBalance(root.right) <= 0)
            return leftRotate(root);

        // Right Left Case
        if (balance < -1 && getBalance(root.right) > 0) {
            root.right = rightRotate(root.right);
            return leftRotate(root);
        }

        return root;
    }

    // Inorder traversal of the AVL tree
    public void inorder() {
        inorderRec(root);
        System.out.println();
    }

    // Helper method to recursively perform inorder traversal of the AVL tree
    private void inorderRec(AVLNode root) {
        if (root != null) {
            inorderRec(root.left);
            System.out.print(root.key + " ");
            inorderRec(root.right);
        }
    }

    public static void main(String[] args) {
        AVLTree tree = new AVLTree();

        // Insert elements into the AVL tree
        tree.insert(9);
        tree.insert(5);
        tree.insert(10);
        tree.insert(0);
        tree.insert(6);
        tree.insert(11);
        tree.insert(-1);
        tree.insert(1);
        tree.insert(2);

        // Inorder traversal of the AVL tree
        System.out.println("Inorder traversal of AVL tree:");
        tree.inorder();

        // Delete an element from the AVL tree
        int keyToDelete = 10;
        System.out.println("Deleting key " + keyToDelete + " from AVL tree");
        tree.delete(keyToDelete);

        // Inorder traversal after deletion
        System.out.println("Inorder traversal after deletion:");
        tree.inorder();
    }
}

//ArrayList
import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListIteratorExample {
    public static void main(String[] args) {
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        
        Iterator<String> iterator = fruits.iterator();
        
        System.out.println("Using Iterator to traverse through the ArrayList:");
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }
        
        System.out.println("\nUsing for-each loop to traverse through the ArrayList:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        
        iterator = fruits.iterator(); // Reset the iterator
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            if (fruit.startsWith("B")) {
                iterator.remove(); // Remove elements that start with "B"
            }
        }
        
        System.out.println("\nArrayList after removal of elements that start with 'B':");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

//LinkedList
import java.util.LinkedList;
import java.util.Iterator;

public class LinkedListIteratorExample {
    public static void main(String[] args) {
        LinkedList<String> fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        
        Iterator<String> iterator = fruits.iterator();
        
        System.out.println("Using Iterator to traverse through the LinkedList:");
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }
        
        System.out.println("\nUsing for-each loop to traverse through the LinkedList:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        
        iterator = fruits.iterator(); // Reset the iterator
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            if (fruit.startsWith("B")) {
                iterator.remove(); 
            }
        }
        
        System.out.println("\nLinkedList after removal of elements that start with 'B':");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

class TreeNode {
    int key;
    TreeNode left;
    TreeNode right;

    public TreeNode(int key) {
        this.key = key;
        this.left = null;
        this.right = null;
    }
}

public class BinarySearchTree {
    private TreeNode root;

    public BinarySearchTree() {
        root = null;
    }

    // Insert a key into the BST
    public void insert(int key) {
        root = insertRec(root, key);
    }

    // Helper method to recursively insert a key into the BST
    private TreeNode insertRec(TreeNode root, int key) {
        if (root == null) {
            root = new TreeNode(key);
            return root;
        }

        if (key < root.key)
            root.left = insertRec(root.left, key);
        else if (key > root.key)
            root.right = insertRec(root.right, key);

        return root;
    }

    // Inorder traversal of the BST
    public void inorder() {
        inorderRec(root);
        System.out.println();
    }

    // Helper method to recursively perform inorder traversal of the BST
    private void inorderRec(TreeNode root) {
        if (root != null) {
            inorderRec(root.left);
            System.out.print(root.key + " ");
            inorderRec(root.right);
        }
    }

    // Delete a key from the BST
    public void delete(int key) {
        root = deleteRec(root, key);
    }

    // Helper method to recursively delete a key from the BST
    private TreeNode deleteRec(TreeNode root, int key) {
        if (root == null)
            return root;

        // Search for the key to be deleted
        if (key < root.key)
            root.left = deleteRec(root.left, key);
        else if (key > root.key)
            root.right = deleteRec(root.right, key);
        else {
            // Key found, delete this node

            // Case 1: Node with only one child or no child
            if (root.left == null)
                return root.right;
            else if (root.right == null)
                return root.left;

            // Case 2: Node with two children
            // Get the inorder successor (smallest in the right subtree)
            root.key = minValue(root.right);

            // Delete the inorder successor
            root.right = deleteRec(root.right, root.key);
        }

        return root;
    }

    // Helper method to find the inorder successor (smallest in the right subtree)
    private int minValue(TreeNode node) {
        int minValue = node.key;
        while (node.left != null) {
            minValue = node.left.key;
            node = node.left;
        }
        return minValue;
    }

    public static void main(String[] args) {
        BinarySearchTree tree = new BinarySearchTree();

        // Insert elements into the BST
        tree.insert(50);
        tree.insert(30);
        tree.insert(20);
        tree.insert(40);
        tree.insert(70);
        tree.insert(60);
        tree.insert(80);

        // Inorder traversal of the BST
        System.out.println("Inorder traversal of BST:");
        tree.inorder();

        // Delete an element from the BST
        int keyToDelete = 30;
        System.out.println("Deleting key " + keyToDelete + " from BST");
        tree.delete(keyToDelete);

        // Inorder traversal after deletion
        System.out.println("Inorder traversal after deletion:");
        tree.inorder();
    }
}

<html>
<body>
<form action = "sucess.html">
<h1><ul>Registration</hl>
<label>uname :</label>
<input type = "Text" id = "u1"><br>

password:<input type = "password" id="pr"><br>

email:<input type = "Text"><br>

Gender:<input type="radio" id="r1">male
       <input type="radio" id="r1">female
       <input type="radio" id="r1">none

state:
 <select>
 <option value = "TS">TS
 <option value = "AP">AP
 <option value = "TN">TN
 <option value = "BHR">BHR
 </select>

course:<input type="checkbox">java
       <input type="checkbox">se
       <input type="checkbox">wt
       textarea.min=70,max=1000
<button type:"submit"value="click.me"> 

<html>
<body>
<form action ="successfull.html">
<h1>Registration</h1>
<lable>username:<lable>
<input type="text"id=U1><br><br>
<lable>password:<lable>
<input type="password"id="pr"><br><br>
<lable>email:<lable>
<input type="text"id="pr"><br><br>
<lable>gender:<lable>
<input type="radio"id="R1">maless
<input type="radio"id="R2">female<br><br>
state:
<select><br>
<option value="TS">TS
<option value="AP">AP
</select><br>
course:<input type="checkbox">java
	<input type="checkbox">SE
	<input type="checkbox">WT
<lable>remark:<lable><br>
<input type="textarea"min=50><br>	
<button type:"submit">submit

void setup() 
     {  // initialize digital pin LED_BUILTIN as an output.           	
         pinMode(LED_BUILTIN, OUTPUT);
      }
void loop() {  
     digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on
            delay(1000);   // wait for a second 
     digitalWrite(LED_BUILTIN, LOW);   // turn the LED off
            delay(1000);   // wait for a second
}

import RPi.GPIO as GPIO
from time import sleep
GPIO.setwarnings(false)
GPIO.setmode(GPIO.BCM)
Blink_count=3
count=0
LEDPin=17
GPIO.setup(LEDPin,GPIO.OUT)
try:
	while count < Blink_count:
    	GPIO.output(LEDPin,False)
		print("LED OFF")
		sleep(1)
		count+=1
finally:
	GPIO.cleanup()

<html>
<body> 
<br><br>
<br>
<p align="center">
<b>SUCCESSFUL</b>
</html>
</body>

int trig=12;     // GPIO Pin D6
int echo=14;     //GPIO Pin D5
int time_microsec;
int time_ms;
int dist_cm;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode(12,OUTPUT);
  pinMode(14,INPUT);

}

void loop() {
  // put your main code here, to run repeatedly:
digitalWrite(trig,LOW);
delayMicroseconds(2);
digitalWrite(trig,HIGH);
delayMicroseconds(10);
digitalWrite(trig,LOW);

//pulseIn gives time in micro seconds, 1Sec= 1000000 microseconds
time_microsec= pulseIn(echo,HIGH);
time_ms=time_microsec/1000;

dist_cm= (34*time_ms)/2;

Serial.print("Time to travel: ");
Serial.println(time_ms,1);
Serial.print("ms / ");
Serial.print("Distance: ");
Serial.print(dist_cm,1);
Serial.print("cm ");

delay(2000);

import RPi.GPIO as GPIO  
import time  
GPIO.setmode(GPIO.BCM)  
GPIO_TRIG = 11 
 GPIO_ECHO = 18 
GPIO.setup(GPIO_TRIG, GPIO.OUT) 
GPIO.setup(GPIO_ECHO, GPIO.IN)
GPIO.output(GPIO_TRIG, GPIO.LOW) 
 Time.sleep(2)  
GPIO.output(GPIO_TRIG, GPIO.HIGH) 
 Time.sleep(0.00001)  
GPIO.output(GPIO_TRIG, GPIO.LOW) 
 while GPIO.input(GPIO_ECHO)==0:  
  start_time = time.time()  
while GPIO.input(GPIO_ECHO)==1: 
 Bounce_back_time = time.time()  
 pulse_duration = Bounce_back_time - start_time 
 distance = round(pulse_duration * 17150, 2)  
print (f"Distance: {distance} cm")  
GPIO.cleanup()

#include <DHT.h>
#include <DHT_U.h>

#define DHTPIN 2
#define DHTTYPE DHT11
DHT dht(DHTPIN,DHTTYPE);

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  Serial.println(F("DHTxx test!"));
  dht.begin();

}

void loop() {
  // put your main code here, to run repeatedly:
  delay(2000);
  float h= dht.readHumidity();
  float t = dht.readTemperature();
  float f = dht.readTemperature(true);
  if(isnan(h)||isnan(t)||isnan(f))
  {
    Serial.println(F("Failed to read fromDHT sensor !"));
    return;
  }
  Serial.print(F("Humidity : "));
  Serial.print(h);
  Serial.print(F("% Temperature : "));
  Serial.print(t);
  Serial.print(F(" C : "));
  Serial.print(f);
  Serial.print(F(" F : "));
  Serial.println(" ");
  

}

$ git remote add origin https://github.com/OWNER/REPOSITORY.git
# Set a new remote

$ git remote -v
# Verify new remote
> origin  https://github.com/OWNER/REPOSITORY.git (fetch)
> origin  https://github.com/OWNER/REPOSITORY.git (push)

git remote set-url origin NEW_URL

#include <stdio.h>

// Function to print the top part of the decorative box
void print_top() {
    printf("/\\/\\/\\/\\/\\\n");
}

// Function to print the bottom part of the decorative box
void print_bottom() {
    printf("\\/\\/\\/\\/\\/\n");
}

// Function to print the middle part of the decorative box
void print_middle(int how_many) {
    for (int i = 0; i < how_many; i++) {
        printf("\\        /\n");
        printf("/        \\\n");
    }
}

// Main function to demonstrate the functionality
int main() {
    int how_many;

    // Prompt the user for the number of middle parts
    printf("How many middle parts? \n");
    scanf("%d", &how_many);

    // Print the top part
    print_top();
    
    // Print the middle part specified number of times
    print_middle(how_many);
    
    // Print the bottom part
    print_bottom();
    
    return 0;
}

#include <stdio.h>

void print_ascii_rectangle(char symbol, int width, int height)
{
    for(int i =0;i<height;i++)
    {
        for(int j=0;j<width;j++)
        {
            printf("%c",symbol);
        }
        printf("\n");
    }
}

int main()
{
    char symbol;
    int width;
    int height;
    printf("Please enter an ASCII symbol:\n");
    scanf(" %c",&symbol);
    
    printf("Please enter the width:\n");
    scanf("%d",&width);
    printf("Please enter the height:\n");
    scanf("%d",&height);
    print_ascii_rectangle(symbol,width,height);
}

<div class="container text-center">
  <div class="row align-items-end">
    <div class="col">
      One of three columns
    </div>
    <div class="col">
      One of three columns
    </div>
    <div class="col">
      One of three columns
    </div>
  </div>
</div>

#include <stdio.h>

void print_quadratic(int a, int b, int c)
{
    if(a!=0)
    {
        printf("%dx^2 ",a);
    }
    if(b!=0)
    {
        if(b>0)
        {
            printf("+ %dx ",b);
        }
        else
        {
            printf("- %dx ",-b);
        }
    }
    if(c!=0)
    {
        if(c>0)
        {
            printf("+ %d ",c);
        }
        else
        {
            printf("- %d ",-c);
        }
    }
    
}

int main (void)
{
    printf("Enter a:\n");
    printf("Enter b:\n");
    printf("Enter c:\n");
    int a,b,c;
    
    scanf("%d%d%d",&a,&b,&c);
    print_quadratic(a,b,c);
    
}

vector<int> sieveOfEratosthenes(int n) {
    vector<bool> isPrime(n + 1, true);
    isPrime[0] = isPrime[1] = false; // 0 and 1 are not prime numbers

    for (int i = 2; i * i <= n; i++) {
        if (isPrime[i]) {
            for (int j = i * i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }

    std::vector<int> primes;
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
        }
    }

    return primes;
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        body, html {
            margin: 0;
            padding: 0;
            width: 100%;
            height: 100%;
            display: flex;
            justify-content: center;
            align-items: center;
            background-color: black;
        }
        img {
            max-width: 100%;
            max-height: 100%;
        }
    </style>
    <title>Image Viewer</title>
</head>
<body>
    <img src="path_to_your_image.jpg" alt="Image">
</body>
</html>

import java.util.ArrayList;
import java.util.List;

class TreeNode<T extends Comparable<T>> {
    T value;
    TreeNode<T> left;
    TreeNode<T> right;

    TreeNode(T value) {
        this.value = value;
        left = null;
        right = null;
    }
}

public class BinarySearchTree<T extends Comparable<T>> {
    private TreeNode<T> root;

    // Method to insert a new value in the BST
    public void insert(T value) {
        root = insertRec(root, value);
    }

    private TreeNode<T> insertRec(TreeNode<T> root, T value) {
        if (root == null) {
            root = new TreeNode<>(value);
            return root;
        }
        if (value.compareTo(root.value) < 0) {
            root.left = insertRec(root.left, value);
        } else if (value.compareTo(root.value) > 0) {
            root.right = insertRec(root.right, value);
        }
        return root;
    }

    // Method for inorder traversal
    public void inorder() {
        List<T> result = new ArrayList<>();
        inorderRec(root, result);
        System.out.println("Inorder: " + result);
    }

    private void inorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            inorderRec(root.left, result);
            result.add(root.value);
            inorderRec(root.right, result);
        }
    }

    // Method for preorder traversal
    public void preorder() {
        List<T> result = new ArrayList<>();
        preorderRec(root, result);
        System.out.println("Preorder: " + result);
    }

    private void preorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            result.add(root.value);
            preorderRec(root.left, result);
            preorderRec(root.right, result);
        }
    }

    // Method for postorder traversal
    public void postorder() {
        List<T> result = new ArrayList<>();
        postorderRec(root, result);
        System.out.println("Postorder: " + result);
    }

    private void postorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            postorderRec(root.left, result);
            postorderRec(root.right, result);
            result.add(root.value);
        }
    }

    // Main method to test the BST
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        bst.insert(50);
        bst.insert(30);
        bst.insert(20);
        bst.insert(40);
        bst.insert(70);
        bst.insert(60);
        bst.insert(80);

        bst.inorder();   // Inorder traversal
        bst.preorder();  // Preorder traversal
        bst.postorder(); // Postorder traversal
    }
}

import java.util.ArrayList;
import java.util.List;

class TreeNode<T extends Comparable<T>> {
    T value;
    TreeNode<T> left;
    TreeNode<T> right;

    TreeNode(T value) {
        this.value = value;
        left = null;
        right = null;
    }
}

public class BinarySearchTree<T extends Comparable<T>> {
    private TreeNode<T> root;

    // Method to insert a new value in the BST
    public void insert(T value) {
        root = insertRec(root, value);
    }

    private TreeNode<T> insertRec(TreeNode<T> root, T value) {
        if (root == null) {
            root = new TreeNode<>(value);
            return root;
        }
        if (value.compareTo(root.value) < 0) {
            root.left = insertRec(root.left, value);
        } else if (value.compareTo(root.value) > 0) {
            root.right = insertRec(root.right, value);
        }
        return root;
    }

    // Method for inorder traversal
    public void inorder() {
        List<T> result = new ArrayList<>();
        inorderRec(root, result);
        System.out.println("Inorder: " + result);
    }

    private void inorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            inorderRec(root.left, result);
            result.add(root.value);
            inorderRec(root.right, result);
        }
    }

    // Method for preorder traversal
    public void preorder() {
        List<T> result = new ArrayList<>();
        preorderRec(root, result);
        System.out.println("Preorder: " + result);
    }

    private void preorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            result.add(root.value);
            preorderRec(root.left, result);
            preorderRec(root.right, result);
        }
    }

    // Method for postorder traversal
    public void postorder() {
        List<T> result = new ArrayList<>();
        postorderRec(root, result);
        System.out.println("Postorder: " + result);
    }

    private void postorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            postorderRec(root.left, result);
            postorderRec(root.right, result);
            result.add(root.value);
        }
    }

    // Main method to test the BST
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        bst.insert(50);
        bst.insert(30);
        bst.insert(20);
        bst.insert(40);
        bst.insert(70);
        bst.insert(60);
        bst.insert(80);

        bst.inorder();   // Inorder traversal
        bst.preorder();  // Preorder traversal
        bst.postorder(); // Postorder traversal
    }
}

declare 
   invalid_sal Exception;
   s employ.sal%type:=&sal;
begin 
   if (s<3000) then
     raise invalid_sal;
   else
     --insert into employ(sal) values(s);
     dbms_output.put_line('Record inserted');
   end if;
Exception
      when invalid_sal then
           dbms_output.put_line('sal greater ');
end;
/

CREATE TABLE empc (
    emp_id NUMBER PRIMARY KEY,
    name VARCHAR2(100),
    hire_date DATE
);

DECLARE
    CURSOR c IS
        SELECT empno, ename, hiredate
        FROM employee
        WHERE (SYSDATE - hiredate) / 365.25 >= 23;  
    emp_record c%ROWTYPE;
BEGIN
    OPEN c;
    LOOP
        FETCH c INTO emp_record;
        EXIT WHEN c%NOTFOUND;
        INSERT INTO empc (emp_id, name, hire_date)
        VALUES (emp_record.empno, emp_record.ename, emp_record.hiredate);
    END LOOP;
    CLOSE c;
    COMMIT;
EXCEPTION
    WHEN OTHERS THEN
        DBMS_OUTPUT.PUT_LINE('An error occurred: ');
      
END;
/

Declare 
   a integer :=&a;
   i integer;
   
begin
  for i in 1 .. a
   loop
      if (mod(i,2)=0) then
         dbms_output.put_line('even '||i);
     -- else
     -- dbms_output.put_line('odd '||i);
    end if;
  end loop;
end;
/

create or replace procedure swap( num1 in out integer,num2 in out integer)Is 
	temp integer:=0;
begin 
    temp:=num1;
    num1:=num2;
    num2:=temp;  
end;
/
declare 
  a integer:=&a;
  b integer:=&b;
begin 
  dbms_output.put_line('Before swaping '||a||'  '||b);
  swap(a,b);
   dbms_output.put_line('After swaping '||a||'  '||b);

end;
/
  

DECLARE
	em t%rowtype;
	empno t.ename%type;
    
BEGIN
	update  t set ename=upper(ename);
	if sql%found then
   		 DBMS_OUTPUT.PUT_LINE(sql%rowcount||' values updated to uppercase.');
   	else 
   		 dbms_output.put_line('not found');
   end if;
END;
/

DECLARE
    a NUMBER;
BEGIN
    SELECT COUNT(*) INTO a
    FROM t;

    IF a > 0 THEN
        DBMS_OUTPUT.PUT_LINE('At least one row satisfies the condition::  '||a);
    ELSE
        DBMS_OUTPUT.PUT_LINE('No rows satisfy the condition.');
    END IF;
END;
/

declare
	cursor c1 is select * from employ ;
	e employ%rowtype;
begin
	 close c1;
exception 
    when invalid_cursor then
      dbms_output.put_line('invalid cursor');
end;
/

DECLARE
    a NUMBER := &a; -- You can change this value as needed
BEGIN
    UPDATE t SET sal = sal * 1.2 WHERE sal > a;
    DBMS_OUTPUT.PUT_LINE(SQL%ROWCOUNT || ' rows updated.');
END;
/

create or replace trigger setsalzero
before insert on t
for each row
begin
	if :new.sal<0 then
		:new.sal:=0;
	end if;
end;
/

create or replace procedure fibnoci(n in out integer)Is 
  temp integer;
  num1 integer:=0;
  num2 integer:=1;
begin 
   dbms_output.put_line(n);
   for i in 1 ..n
      loop
	dbms_output.put_line(num1||' ');
         temp:=num1;
         num1:=num2;
         num2:=temp+num2;
       
         
    end loop;
end;
/
declare 
  a integer:=&a;
begin 
  fibnoci(a);
end;
/
  

--sum of two numbers
DECLARE
    num1 NUMBER := 10;
    num2 NUMBER := 20;
    sums NUMBER;
BEGIN
    sums := num1 + num2;
    DBMS_OUTPUT.PUT_LINE(sums);
END;
/

CREATE OR REPLACE TRIGGER trg
--before insert ON t
before update of sal on t
 --after insert on t
FOR EACH ROW
BEGIN
    DBMS_OUTPUT.PUT_LINE('A new record is being inserted into the employee table:');
    DBMS_OUTPUT.PUT_LINE('Employee ID: ' || :New.empno);
    DBMS_OUTPUT.PUT_LINE('Employee Name: ' || :New.ename);
    --DBMS_OUTPUT.PUT_LINE('Hire Date: ' || TO_CHAR(:NEW.hiredate, 'YYYY-MM-DD'));
END;
/

CREATE OR REPLACE TRIGGER salary_trigger
BEFORE UPDATE OF sal ON e
FOR EACH ROW
BEGIN
    IF :OLD.sal <> 
	:NEW.sal THEN
        DBMS_OUTPUT.PUT_LINE('Salary changed for employee ' || :OLD.employee_id || ': ' || :OLD.sal || ' -> ' || :NEW.sal);
    END IF;
END;
/

CREATE OR REPLACE PROCEDURE square_cube (n IN NUMBER,square OUT NUMBER,cube OUT NUMBER) IS
BEGIN
    square := n * n;
    cube := n * n * n;
END square_cube;
/
DECLARE
    v_number NUMBER := 4;
    v_square NUMBER;      
    v_cube NUMBER;       
BEGIN
    square_cube(v_number, v_square, v_cube);
    DBMS_OUTPUT.PUT_LINE('Number: ' || v_number);
    DBMS_OUTPUT.PUT_LINE('Square: ' || v_square);
    DBMS_OUTPUT.PUT_LINE('Cube: ' || v_cube);
END;
/

 CREATE OR REPLACE FUNCTION calculate_square (input_number IN NUMBER,output_result OUT NUMBER) RETURN NUMBER IS
BEGIN
    output_result := input_number * input_number;
    RETURN output_result;
END calculate_square;
/
DECLARE
    input_number NUMBER := 5;
    output_result NUMBER;
BEGIN
    output_result := NULL;
    output_result := calculate_square(input_number, output_result);

    DBMS_OUTPUT.PUT_LINE('Input number: ' || input_number);
    DBMS_OUTPUT.PUT_LINE('Square of the input number: ' || output_result);
END;
/

CREATE OR REPLACE Procedure cs(num IN NUMBER,result OUT NUMBER) IS
BEGIN
    result := num * num;
END cs;
/
DECLARE
    input_number NUMBER := 5;
    output_result NUMBER;
BEGIN
    cs(input_number, output_result);
    DBMS_OUTPUT.PUT_LINE('Square of ' || input_number || ': ' || output_result);
END;
/

CREATE OR REPLACE FUNCTION rectangle_area (length IN NUMBER,width IN NUMBER) RETURN NUMBER IS
    area NUMBER;
BEGIN
    area := length * width;
    RETURN area;
END rectangle_area;
/
DECLARE
	length NUMBER := 5;
	width NUMBER := 4;
	area NUMBER;
BEGIN
      area := rectangle_area(length, width);      
      DBMS_OUTPUT.PUT_LINE('Length: ' || length);
      DBMS_OUTPUT.PUT_LINE('Width: ' || width);
      DBMS_OUTPUT.PUT_LINE('Area of the rectangle: ' || area);
  END;
/

DECLARE
    radius NUMBER := &radius;
    area NUMBER;
BEGIN
    area := 3.14159 * radius * radius;
    DBMS_OUTPUT.PUT_LINE('Radius: ' || radius);
    DBMS_OUTPUT.PUT_LINE('Area of the circle: ' || area);
END;
/
 

vector<string> valid;
  void generate(string& s , int open,int close)
  {
    
    if(open==0 && close==0)
    {
        valid.push_back(s);
        return;
    }
    if(open>0)
    {
        s.push_back('(');
        generate(s,open-1,close);
        s.pop_back();
    }
    if(close>0 && open<close)
    {
        s.push_back(')');
        generate(s,open,close-1);
        s.pop_back();
    }
  }

package test;

import java.sql.*;

public class TesteConexao {
    public static void main(String[] args) {
        String url = "jdbc:mysql://root:VCIiGnIpVpAUCfAXxdaPSTvTvAJSNGuE@viaduct.proxy.rlwy.net:21894/railway";
        String usuario = "root";
        String senha = "VCIiGnIpVpAUCfAXxdaPSTvTvAJSNGuE";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha)) {
            String sql = "SELECT * FROM Funcionarios";
            Statement statement = conexao.createStatement();
            ResultSet resultSet = statement.executeQuery(sql);

            while (resultSet.next()) {
                int id = resultSet.getInt("idFuncionario");
                String nome = resultSet.getString("nomeFuncionario");
                String email = resultSet.getString("email");
                String senhaFuncionario = resultSet.getString("senha");
                String estadoLogin = resultSet.getString("estadoLogin");
                System.out.println("ID: " + id + ", Nome: " + nome + ", Email: " + email + ", Senha: " + senhaFuncionario + ", Estado de Login: " + estadoLogin);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}