Client.java

public class Client {
    private Integer clientId;
    private String name;
    private String email;
    private String phoneNumber;
    private String country;

    public Client(Integer clientId, String name, String email, String phoneNumber, String country) {
        this.clientId = clientId;
        this.name = name;
        this.email = email;
        this.phoneNumber = phoneNumber;
        this.country = country;
    }

    // Getters and Setters
    public Integer getClientId() {
        return clientId;
    }

    public void setClientId(Integer clientId) {
        this.clientId = clientId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    // Override toString method for CSV format
    @Override
    public String toString() {
        return clientId + "," + name + "," + email + "," + phoneNumber + "," + country;
    }
}

Main.java**

 import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
            FileUtility fileUtility = new FileUtility();
            Client[] clients = fileUtility.readFileData(br);
            Arrays.sort(clients, Comparator.comparing(Client::getClientId));
            fileUtility.writeDataToFile(clients);
            System.out.println("Output file generated successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
FileUtility.java**
  
  import java.io.*;
import java.util.*;

public class FileUtility {
    public Client[] readFileData(BufferedReader br) throws IOException {
        List<Client> clientList = new ArrayList<>();
        String line;
        while ((line = br.readLine()) != null) {
            String[] parts = line.split(",");
            Integer clientId = Integer.parseInt(parts[0].trim());
            String name = parts[1].trim();
            String email = parts[2].trim();
            String phoneNumber = parts[3].trim();
            String country = parts[4].trim();
            clientList.add(new Client(clientId, name, email, phoneNumber, country));
        }
        br.close();
        return clientList.toArray(new Client[0]);
    }

    public void writeDataToFile(Client[] clientArray) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.csv"))) {
            for (Client client : clientArray) {
                writer.write(client.toString());
                writer.newLine();
            }
        }
    }
}

public class Pair<K, V> {
    private K key;
    private V val;
    
    public Pair(K key, V val) {
        this.key = key;
        this.val = val;
    }
    
    public K getKey() {
        return this.key;
    }
    
    public V getVal() {
        return this.val;
    }
    
    public static void main(String[] args) {
        Pair<Integer, String> p1 = new Pair<>(123, "abc");
        Integer i = p1.getKey();
        System.out.println(i);
        System.out.println(p1.getVal());
    }
}

**Main.java**

import java.io.*;
import java.util.Scanner;
 public class Main {
public static void main(String[] args) {
 try {
Scanner scanner = new Scanner(System.in);
// Get airport details from the user
 System.out.println("Enter the name of the airport:");
String name = scanner.nextLine();
System.out.println("Enter the city name:");
String cityName = scanner.nextLine();
System.out.println("Enter the country code:");
 String countryCode = scanner.nextLine();
 // Write airport details to a CSV file
 FileWriter writer = new FileWriter("airport.csv");
writer.write(name + "," + cityName + "," + countryCode);
writer.close();
System.out.println("Airport details have been written to airport.csv successfully.");
 }
catch (IOException e) {
System.out.println("An error occurred while writing to the file.");
 e.printStackTrace();
}
 }
}   

public class Container<T> {
    private T obj;

    public Container(T obj) {
        this.obj = obj;
    }

    public T getObj() {
        return this.obj;
    }

    public void showType() {
        System.out.println("Type: " + obj.getClass().getName());
    }

    public static void main(String[] args) {
        Container<String> c1 = new Container<>("generic");
        String s = c1.getObj();
        System.out.println("String is: " + s);
        c1.showType();

        Container<Integer> c2 = new Container<>(123);
        Integer i = c2.getObj();
        System.out.println("Integer is: " + i);
        c2.showType();
    }
}

//GameScreenLevel1.cpp
void GameScreenLevel1::SetLevelMap() {
	//0 blank, 1 wall, 2 win condition
	int map[MAP_HEIGHT][MAP_WIDTH] = {
		{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
		{1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1},
		{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
		{0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0},
		{1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1},
		{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
		{1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1},
		{0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0},
		{0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0},
		{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
	};

	//Clear up any old map
	if (mLevelMap != NULL)
	{
		delete mLevelMap;

	}

	//Set up the new one
	mLevelMap = new LevelMap(map);
}


//Collision.cpp
bool Collision::Circle(Character* character1, Character* character2) {
	//Calculate Vector between 2 characters
	Vector2D vec = Vector2D((character1->GetPosition().x - character2->GetPosition().x), (character1->GetPosition().y - character2->GetPosition().y));

	//Calculate lenght from vector
	double distance = sqrt((vec.x * vec.x) + (vec.y * vec.y));

	//Get Collision Radius 
	double combinedDistance = (character1->GetCollisionRadius() - character2->GetCollisionRadius());

	if (distance < combinedDistance) {
		return true;
	}
	else return false;
}

bool Collision::Box(Rect2D rect1, Rect2D rect2) {
	if (rect1.x + (rect1.width / 2) > rect2.x && rect1.x + (rect1.width / 2) < rect2.x + rect2.width && rect1.y + (rect1.height / 2) > rect2.y && rect1.y + (rect1.height / 2) < rect2.y + rect2.height) {
		return true;
	}
	return false;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int n_pages, size_page, n_frames, size_physical_memory, size_logical_memory;
int m, n,i,j;
int p = 0, d = 0;

int find_p(int),find_d(int);


int main()
{
    // Scanning size of Physical memory
    printf("Enter size of physical memory (power of 2)=  ");
    scanf("%d", &size_physical_memory);

    // Scanning the size of page
    // Frame size == Page size
    printf("Enter size of page/frame (power of 2)=  ");
    scanf("%d", &size_page);

    // Scanning number of pages in logical memory
    //printf("Enter no. of pages = ");
  //  scanf("%d", &n_pages);

   // size_logical_memory = size_page * n_pages;
   printf("Enter size of logical memory (power of 2)= ");
   scanf("%d",&size_logical_memory);
    n_pages=size_logical_memory/size_page;

    // Calculating the number of frames in the Physical memory
    n_frames = size_physical_memory / size_page;

    printf("\n\t\t\tLogical-Memory\t\tPhysical-Memory\n");
    printf("No. of Pages/frames\t\t%d\t\t\t%d\n", n_pages, n_frames);
    printf("Page/Frame size\t\t\t%d\t\t\t%d\n", size_page, size_page);
    printf("Size of Memory\t\t\t%d\t\t\t%d\n\n", size_logical_memory, size_physical_memory);

    // Declaring the Pages,Frames and Pagetable
    char pages[n_pages][size_page];
    int pagetable[n_pages];
    char frames[n_frames][size_page];

    n = sqrt(size_page);
    m = sqrt(size_page * n_pages);

    getchar();

    // Scanning Pages data
    printf("Enter details of the data availalbe in Logical Address Space\n");
    for (i = 0; i < n_pages; i++)
    {
        printf(" Enter the page%d data : ", (i));
        for (j = 0; j < size_page; j++)
        {
			pages[i][j] = getchar();
            getchar();
        }
    }

//Data Available in Logical Address
	printf("\nData Available in Logical Address is:\n");
	for (i = 0; i < n_pages; i++)
    {
        printf("\n Page%d: ", (i));
        for (j = 0; j < size_page; j++)
        {
			printf("%c\t",pages[i][j]);
        }
    }


    // Scanning Pagetable data
    printf("\nEnter the details of page table : \n");
for (i = 0; i < n_pages; i++) {
    printf(" Page%d stored in Frame: ", i);
    scanf("%d", &pagetable[i]);
}

	
        // Initializing all the default frames values to '0'
    for (i = 0; i < n_frames; i++){
        for (j = 0; j < size_page; j++)
        {
            frames[i][j] = '-';
        }
    }



    // Placing the data from pages to frams using page table
    for (i = 0; i < n_pages; i++)
    {
        p = i;
        int f = pagetable[p];
        for (j = 0; j < size_page; j++)
        {
            d = j;
            // Initializing Frames using (f,d)
            frames[f][d] = pages[i][j];
        }
    }

    // Displaying the Frames data
    printf("\nAccording to the given Page Table information \nFrames in the Physical Memory are loaded with following data:\n");
    for (i = 0; i < n_frames; i++)
    {
        printf(" \tFrame%d: ",i);
		for (j = 0; j < size_page; j++)
            printf("%c ", frames[i][j]);
        printf("\n");
    }
    printf("\n");

    // Finding the Physical address through Logical address
    printf("Enter any one address of Logical Memory : ");
    int n;
    scanf("%d", &n);
    p = find_p(n);
    d = find_d(n);
    int f = pagetable[p];
    printf(" Calculated Page Number is: %d\n",p);
    printf(" Calculated Displacement is: %d",d);
    printf("\nThe Physical address of %d (given Logical Address) is %d\n", n, (f * size_page) + d);
    printf("Data item \"%c\" of Logical Address %d is found at Physical Address %d i.e., at Frame Number %d with Displacement %d = \"%c\"\n", pages[n/4][n%4], n, (f * size_page) + d, f, d, frames[f][d]);


    
}

int find_p(int n)
{
    int res = n / size_page;
    return res;
}

int find_d(int n)
{
    int res = n % size_page;
    return res;
}

import {
  ButtonContent,
  DestructiveButton,
  Form,
  FormControl,
  FormField,
  FormItem,
  FormLabel,
  FormMessage,
  Icon,
  Input,
  Toaster,
  Tooltip,
  TooltipContent,
  TooltipProvider,
  TooltipTrigger,
} from "ui";
import { zodResolver } from "@hookform/resolvers/zod";
import { useForm } from "react-hook-form";
import * as z from "zod";
import React, { useState } from "react";
import { toast } from "sonner";
import wretch from "wretch";
import { useGetVesselFromIMO } from "@/hooks";

const formSchema = z.object({
  imo: z.string().max(7),
  cargo_type: z.string().optional(),
  cargo_sub_type: z.string().optional(),
  mmsi: z.string().max(9).optional(),
  vessel_name: z.string().optional(),
  year_of_build: z.string().optional(),
  flag: z.string().optional(),
  grt: z.string().optional(),
  dwt: z.string().optional(),
  overall_length: z.string().optional(),
  beam: z.string().optional(),
});

const fieldsNameHelper = {
  imo: {
    name: "IMO",
    description: "International Maritime Organization identifier",
  },
  cargo_type: {
    name: "Cargo Type",
    description: "The type of cargo the vessel carries",
  },
  cargo_sub_type: {
    name: "Cargo Sub Type",
    description: "The subtype of cargo the vessel carries",
  },
  mmsi: { name: "MMSI", description: "Maritime Mobile Service Identity" },
  vessel_name: { name: "Vessel Name", description: "The name of the vessel" },
  year_of_build: {
    name: "Year of Build",
    description: "The year the vessel was built",
  },
  flag: { name: "Flag", description: "The flag country code" },
  grt: { name: "GRT", description: "Gross Registered Tonnage" },
  dwt: { name: "DWT", description: "Dead Weight Tonnage" },
  overall_length: {
    name: "Overall Length",
    description: "The overall length of the vessel",
  },
  beam: { name: "Beam", description: "The beam of the vessel" },
};

export function VesselInfoForm() {
  const [imoChecked, setImoChecked] = useState(false);
  const [updateError, setUpdateError] = useState(null);
  const form = useForm({
    resolver: zodResolver(formSchema),
    defaultValues: {},
  });

  const imoValue = form.watch("imo");
  const {
    data: vesselData,
    isError,
    isLoading,
  } = useGetVesselFromIMO(imoValue);

  async function onSubmit(values) {
    setUpdateError(null);
    try {
      if (!imoChecked) {
        setImoChecked(true);
        if (vesselData?.length) {
          toast.error("Vessel already exists");
        }
      } else {
        const response = await wretch("/api/form/insertVessel")
          .post(values)
          .res();
        if (response.ok) {
          toast.success("Success!", {
            description: "Vessel details added.",
          });
          form.reset();
          setImoChecked(false);
        } else {
          throw new Error("Error submitting form");
        }
      }
    } catch (error) {
      setUpdateError(error);
    }
  }

  return (
    <div className={"mt-4"}>
      <Form {...form}>
        <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
          <FormField
            control={form.control}
            name="imo"
            render={({ field }) => (
              <FormItem className={"flex flex-row items-center"}>
                <FormLabel className={"w-64 text-lg font-light"}>
                  {fieldsNameHelper.imo.name}
                </FormLabel>
                <div className={"mr-2"}>
                  <TooltipProvider>
                    <Tooltip>
                      <TooltipTrigger className="text-black hover:text-black/50 dark:text-white dark:hover:text-white/50">
                        <Icon name="unknown" style="h-5 w-5" />
                      </TooltipTrigger>
                      <TooltipContent>
                        <p>{fieldsNameHelper.imo.description}</p>
                      </TooltipContent>
                    </Tooltip>
                  </TooltipProvider>
                </div>
                <FormControl className={"w-full"}>
                  <Input
                    {...field}
                    className={"text-md font-light"}
                    type="text"
                    value={field.value ?? ""}
                  />
                </FormControl>
                <FormMessage />
              </FormItem>
            )}
          />
          {imoChecked && vesselData && vesselData.length > 0 ? (
            <div className="vessel-info">
              <h2 className="text-lg font-semibold">Vessel Information</h2>
              <ul>
                {Object.keys(fieldsNameHelper).map(
                  (key) =>
                    vesselData[0][key] && (
                      <li key={key}>
                        <strong>{fieldsNameHelper[key].name}:</strong>{" "}
                        {vesselData[0][key]}
                      </li>
                    ),
                )}
              </ul>
            </div>
          ) : null}
          {imoChecked &&
            (!vesselData || vesselData.length === 0) &&
            Object.keys(formSchema.shape).map(
              (key, index) =>
                key !== "imo" && (
                  <FormField
                    key={key + index}
                    control={form.control}
                    name={key}
                    render={({ field }) => (
                      <FormItem className={"flex flex-row items-center"}>
                        <FormLabel className={"w-64 text-lg font-light"}>
                          {fieldsNameHelper[key].name}
                        </FormLabel>
                        <div className={"mr-2"}>
                          <TooltipProvider>
                            <Tooltip>
                              <TooltipTrigger className="text-black hover:text-black/50 dark:text-white dark:hover:text-white/50">
                                <Icon name="unknown" style="h-5 w-5" />
                              </TooltipTrigger>
                              <TooltipContent>
                                <p>{fieldsNameHelper[key].description}</p>
                              </TooltipContent>
                            </Tooltip>
                          </TooltipProvider>
                        </div>
                        <FormControl className={"w-full"}>
                          <Input
                            {...field}
                            className={"text-md font-light"}
                            type="text"
                            value={field.value ?? ""}
                          />
                        </FormControl>
                        <FormMessage />
                      </FormItem>
                    )}
                  />
                ),
            )}
          <div className="flex flex-row justify-end">
            <DestructiveButton type="submit" className="mt-4">
              <ButtonContent>
                {imoChecked ? "Add Vessel" : "Check IMO"}
              </ButtonContent>
            </DestructiveButton>
          </div>
          <Toaster />
        </form>
      </Form>
    </div>
  );
}

import {type NextPage} from "next";
import {Button, HeadingLink, MinimalPage, PageHeading} from "ui";
import {CommandInterface} from "@/components";
import {useRouter} from "next/router";
import {VesselButton} from "@/components/buttons/vesselButton";
import React from "react";

const ManageVessel: NextPage = () => {
  const router = useRouter();
  return (
    <MinimalPage
      pageTitle={"Manage Vessel | Email Interface"}
      pageDescription={"Spot Ship Email Interface | Manage Vessel"}
      commandPrompt
    >
      <CommandInterface/>
      <div className="w-full">
        <HeadingLink icon={"back"} text={"Home"} href={`/secure/home`}/>
      </div>
      <div>
        <PageHeading text="Manage Vessel"/>
      </div>
      <div className="grid w-full grid-flow-row auto-rows-max gap-8 p-8 pt-16 lg:w-2/3 lg:grid-cols-2">
        <Button
          text="Add Vessel"
          icon="plus-circle"
          iconRight
          action={() => {
            router.push("/secure/manager/manageVessel/addVessel");
          }}
          colour="Primary"
        />
        <Button
          text="Add Regular Vessel"
          icon="plus-circle"
          iconRight
          action={() => {
            router.push("/secure/manager/manageVessel/addRegularVessel");
          }}
          colour="Primary"
        />
        <Button
          text="Edit Vessel"
          icon="edit"
          iconRight
          action={() => {
            router.push("/secure/manager/manageVessel/editVessel");
          }}
          colour="Secondary"
        />
      </div>
      <div className="grid w-full grid-flow-row auto-rows-max gap-8 px-8 lg:w-2/3 lg:grid-cols-2">
        <VesselButton/>
      </div>
    </MinimalPage>
  );
};

export default ManageVessel;

import { NextPage } from "next";
import {
  BackHomeButton,
  CommandPalletteButton,
  MinimalPage,
  PageHeading,
} from "ui";
import { VesselInfoForm } from "@/components/forms/vesselInfoForm";
import { BugReportButton, CommandInterface, Navigation } from "@/components";

const RegularVessel: NextPage = () => {
  return (
    <MinimalPage
      pageTitle={"Regular Vessel Info | Vessel Interface"}
      pageDescription={"Vessel Interface | Regular Vessel Info"}
      commandPrompt
    >
      <div className="flex w-full flex-row justify-between pl-1 pt-1">
        <div>
          <BackHomeButton />
        </div>
        <Navigation />
        <div className="flex flex-row gap-4">
          <BugReportButton />
          <CommandPalletteButton />
          <CommandInterface />
        </div>
      </div>
      <PageHeading text="Regular Vessel Info" />
      <VesselInfoForm />
    </MinimalPage>
  );
};

export default RegularVessel;

var jwt = require('jsonwebtoken');

function auth(req, res, next) {
    // Extract the token from the Authorization header
    const authHeader = req.headers.authorization;

    if (!authHeader) {
        return res.status(401).send('Authorization header is missing');
    }

    // Ensure the token is a Bearer token
    const tokenParts = authHeader.split(' ');

    if (tokenParts.length !== 2 || tokenParts[0] !== 'Bearer') {
        return res.status(401).send('Invalid Authorization header format');
    }

    const token = tokenParts[1];

    // Verify the token
    jwt.verify(token, 'sid', function(err, decoded) {
        if (err) {
            return res.status(401).send('Failed to authenticate token');
        } else {
            // Optionally, you can attach the decoded information to the request object
            req.user = decoded;
            next();
        }
    });
}

module.exports = auth;

devtools::install_github("bioFAM/MOFA2", build_opts = c("--no-resave-data --no-build-vignettes"))

{
    "email": "harsh14@gmail.com",
    "password": "StrongPassword123!"
}

Int ledpin=2;
Void setup(){
	pinMode(ledpin,OUTPUT);
Serial.begin(9600);
}
Void loop(){
	digitalWrite(ledpin,HIGH);
	delay(1000);
	digitalWrite(ledpin,LOW);
	delay(1000);
}

#include “DHT.h”
DHT dht 2(2,DHT11);
Void setup(){
Serial.begin(9600);
}
Void loop(){
Serial.print(F(“Humidity in c: “));
Serial.print(dht.readHumidity());
Serial.print(F(“% temperature : “));
Serial.print(dht2.readTemperature());
Delay(1000);
}

int trig=D6
int echo=D5
float duration,dist_cm,dist_in
void setup(){
	pinMode(trig,OUTPUT)
	pinMode(echo,INPUT)
	Serial.begin(9600)
}
Void loop(){
	digitalWrite(trig,LOW);
	delay Microseconds(2);
	digitalWrite(trig,HIGH);
	delay Microseconds(10);
	digitalWrite(trig,LOW);
	duration=pulseIn(echo,HIGH);
	dist_cm=duration*0.0343/2.0;
	dist_in=duration*0.0135/2.0;
	Serial.print(“Distance”);
	Serial.print(dist_cm,1);
	Serial.print(“cm/ ”);
	Serial.print(dist_in,1);
	delay(300);
}

Void setup(){
	pinMode(LED_BUILTIN,OUTPUT);
}
Void loop(){
	digitalWrite(LED_BUILTIN,HIGH);
	delay(1000);
	digitalWrite(LED_BUILTIN,LOW);
	delay(1000);
}

#include <DHT.h>

#define DHTPIN 2
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  Serial.println("Dht test!!");
}

void loop() {
  delay(2000);
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  float f = dht.readTemperature(true);

  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }

  Serial.print("Humidity: ");
  Serial.print(h);
  Serial.print("% Temperature: ");
  Serial.print(t);
  Serial.print("C ");
  Serial.println(f);
}

int trig=12
int echo=11
float duration,dist_cm,dist_in
void setup(){
	pinMode(trig,OUTPUT)
	pinMode(echo,INPUT)
	Serial.begin(9600)
}
Void loop(){
	digitalWrite(trig,LOW);
	delay Microseconds(2);
	digitalWrite(trig,HIGH);
	delay Microseconds(10);
	digitalWrite(trig,LOW);
	duration=pulseIn(echo,HIGH);
	dist_cm=duration*0.0343/2.0;
	dist_in=duration*0.0135/2.0;
	Serial.print(“Distance”);
	Serial.print(dist_cm,1);
	Serial.print(“cm/ ”);
	Serial.print(dist_in,1);
	delay(300);
}

From gpiozero import LED
From time import sleep
Led=LED(17)
While True:
	Led.on()
	Sleep(1)
	Led.off
	Sleep(1)
Standard program:
import RPi.GPIO as GPIO
from time import sleep
 GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
 
led_pin = 17
Blink_count=3
Count=0
While(Count<Blink_count):
	GPIO.output(led_pin,true)
	Print(“led on!!”)
	Sleep(3)
	Count+=1
	GPIO.output(led_pin,false)
	Print(“led off!!”)
	Sleep(1)
	Count+=1
Finally:  GPIO.cleanup()

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()

// first parameter is the Accumulator and 2nd is the current value
let result = [1, 2, 3, 4].reduce(function (a, b) {
    //console.log(a, b)
    return a + b;
});

result

// get total of the all items
let products = [
    { name: "Cucumber", type: "vegetable", price: 45.0 },
    { name: "Banana", type: "fruit", price: 20.0 },
    { name: "Carrot", type: "vegetable", price: 20.0 },
    { name: "Apple", type: "fruit", price: 75.0 }
];


let total = products.reduce((total, product) => {
    return total + product.price
}, 0)

total

// create a dictionary of the products by name

let lookup = products.reduce((dictionary, product) => {
    dictionary[product.name] = product; // fixed the syntax error
    return dictionary;
}, {});

console.log(lookup["Banana"].type) // lookup["Banana"].price


let people = [
    { name: "Jane", age: 34 },
    { name: "Mark", age: 20 },
    { name: "Abby", age: 20 },  
]


// group by age

let groupedByAge = people.reduce((dictionary, person) => {
    dictionary[person.age] = dictionary[person.age] || []; // fixed the syntax error
    dictionary[person.age].push(person);
    return dictionary;
}, {});


groupedByAge


// Extra parameters

let test = [1, 2, 3, 4].reduce(function (accumulator, item, index, array) {
    console.log(index)
    console.log(array)
    return accumulator + item;
}, 0);

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

body {
  height: 100vh;
  display: grid;
  place-items: center;
  overflow: hidden;
}

main {
  position: relative;
  width: 100%;
  height: 100%;
  box-shadow: 0 3px 10px rgba(0, 0, 0, 0.3);
}

.item {
  width: 200px;
  height: 300px;
  list-style-type: none;
  position: absolute;
  top: 50%;
  transform: translateY(-50%);
  z-index: 1;
  background-position: center;
  background-size: cover;
  border-radius: 20px;
  box-shadow: 0 20px 30px rgba(255, 255, 255, 0.3) inset;
  transition: transform 0.1s, left 0.75s, top 0.75s, width 0.75s, height 0.75s;

  &:nth-child(1),
  &:nth-child(2) {
    left: 0;
    top: 0;
    width: 100%;
    height: 100%;
    transform: none;
    border-radius: 0;
    box-shadow: none;
    opacity: 1;
  }

  &:nth-child(3) {
    left: 50%;
  }
  &:nth-child(4) {
    left: calc(50% + 220px);
  }
  &:nth-child(5) {
    left: calc(50% + 440px);
  }
  &:nth-child(6) {
    left: calc(50% + 660px);
    opacity: 0;
  }
}

.content {
  width: min(30vw, 400px);
  position: absolute;
  top: 50%;
  left: 3rem;
  transform: translateY(-50%);
  font: 400 0.85rem helvetica, sans-serif;
  color: white;
  text-shadow: 0 3px 8px rgba(0, 0, 0, 0.5);
  opacity: 0;
  display: none;

  & .title {
    font-family: "arial-black";
    text-transform: uppercase;
  }

  & .description {
    line-height: 1.7;
    margin: 1rem 0 1.5rem;
    font-size: 0.8rem;
  }

  & button {
    width: fit-content;
    background-color: rgba(0, 0, 0, 0.1);
    color: white;
    border: 2px solid white;
    border-radius: 0.25rem;
    padding: 0.75rem;
    cursor: pointer;
  }
}

.item:nth-of-type(2) .content {
  display: block;
  animation: show 0.75s ease-in-out 0.3s forwards;
}

@keyframes show {
  0% {
    filter: blur(5px);
    transform: translateY(calc(-50% + 75px));
  }
  100% {
    opacity: 1;
    filter: blur(0);
  }
}

.nav {
  position: absolute;
  bottom: 2rem;
  left: 50%;
  transform: translateX(-50%);
  z-index: 5;
  user-select: none;

  & .btn {
    background-color: rgba(255, 255, 255, 0.5);
    color: rgba(0, 0, 0, 0.7);
    border: 2px solid rgba(0, 0, 0, 0.6);
    margin: 0 0.25rem;
    padding: 0.75rem;
    border-radius: 50%;
    cursor: pointer;

    &:hover {
      background-color: rgba(255, 255, 255, 0.3);
    }
  }
}

@media (width > 650px) and (width < 900px) {
  .content {
    & .title {
      font-size: 1rem;
    }
    & .description {
      font-size: 0.7rem;
    }
    & button {
      font-size: 0.7rem;
    }
  }
  .item {
    width: 160px;
    height: 270px;

    &:nth-child(3) {
      left: 50%;
    }
    &:nth-child(4) {
      left: calc(50% + 170px);
    }
    &:nth-child(5) {
      left: calc(50% + 340px);
    }
    &:nth-child(6) {
      left: calc(50% + 510px);
      opacity: 0;
    }
  }
}

@media (width < 650px) {
  .content {
    & .title {
      font-size: 0.9rem;
    }
    & .description {
      font-size: 0.65rem;
    }
    & button {
      font-size: 0.7rem;
    }
  }
  .item {
    width: 130px;
    height: 220px;

    &:nth-child(3) {
      left: 50%;
    }
    &:nth-child(4) {
      left: calc(50% + 140px);
    }
    &:nth-child(5) {
      left: calc(50% + 280px);
    }
    &:nth-child(6) {
      left: calc(50% + 420px);
      opacity: 0;
    }
  }
}

ol.custom-ordered-list{
       counter-reset: list-counter; /* Initialize the counter */
        list-style: none; /* Remove default list styling */
        padding-left: 0; /* Remove default padding */       
    li{
            counter-increment: list-counter; /* Increment the counter */
            position: relative; /* Positioning for the pseudo-element */
            padding-left: 60px; /* Space for the counter */
            padding-bottom: 12px;
            line-height: 30px;
            left: 0;
        
        &:before{
            content: counter(list-counter, decimal-leading-zero) ""; /* Display the counter with leading zeros */
            position: absolute; /* Position it absolutely within the list item */
            left: 0; /* Align it to the left */
            width: 2em; /* Width for the counter */
            text-align: right; /* Align text to the right */
            font-size: 24px;
            font-weight: bold;
            color: #2E844B;
        }
    }
}

 ListNode *hasCycle(ListNode *head) {
        ListNode *slow=head;
        ListNode *fast=head;
      while(fast!=NULL && fast->next!=NULL)
      {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)
        return slow;
      }
     return NULL;
    }
    ListNode *detectCycle(ListNode *head) {
         ListNode *t1=hasCycle(head);
         if(t1==NULL)return NULL;
        ListNode *t=head;
       

        while(t!=t1)
        {
            t=t->next;
            t1=t1->next;
        }
        return t;
        
    }

import tensorflow as tf
mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
  loss='sparse_categorical_crossentropy',
  metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test, y_test)

bool hasCycle(ListNode *head) {
        ListNode *slow=head;
        ListNode *fast=head;
      while(fast!=NULL && fast->next!=NULL)
      {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)
        return true;
      }
      return false;
    }

 bool hasCycle(ListNode *head) {
        ListNode* temp = head;
        unordered_map<ListNode*,int> m;
         while(temp != NULL) {
            m[temp]++;
            if(m[temp] == 2) {
                return true;
            }
            temp = temp->next;
        }

        return false;
    }

from pymongo import MongoClient

# Configure MongoDB connection
client = MongoClient('mongodb://localhost:27017/')
db = client['twitter_database']
collection = db['tweets']

# Find the last tweet in the collection
last_tweet = collection.find_one({}, sort=[('$natural', -1)])


# Print the last tweet
print(last_tweet)

from pymongo import MongoClient

mongo_uri = "mongodb://localhost:27017/"
database_name = "twitter_database"

source_collection_name = "tweets"
target_collection_name = "tweet_data"

fields_to_extract = [
    "json_data.id",
    "json_data.user.id",
    "json_data.created_at",
    "json_data.in_reply_to_status_id",
    "json_data.in_reply_to_user_id",
    "json_data.lang",
    "json_data.place",
    "json_data.user.location",
    "json_data.is_quote_status"
]

# not sure why but it works :)
def get_nested_field(data, field_path):
    keys = field_path.split('.')
    for key in keys:
        data = data.get(key)
        if data is None:
            return None
    return data
client = MongoClient(mongo_uri)
db = client[database_name]
source_collection = db[source_collection_name]
target_collection = db[target_collection_name]

cursor = source_collection.find()
for doc in cursor:
    lang = get_nested_field(doc, "json_data.lang")
    
    # Check if lang
    if lang in ["en", "nl", "es"]:
        # Create a new document with only the specified fields
        new_doc = {field: get_nested_field(doc, field) for field in fields_to_extract}
        new_doc["_id"] = doc["_id"]  # Keep the original _id
                target_collection.insert_one(new_doc)

client.close()
print("Data successfully transferred to new collections.")

from pymongo import MongoClient

# MongoDB connection details
mongo_uri = "mongodb://localhost:27017/"
database_name = "twitter_database"

# Source and target collections
source_collection_name = "tweets"
target_collection_name = "tweet_data"

# columns to get
fields_to_extract = [
    "json_data.id",
    "json_data.user.id",
    "json_data.created_at",
    "json_data.in_reply_to_status_id",
    "json_data.in_reply_to_user_id",
    "json_data.lang",
    "json_data.place",
    "json_data.user.location",
    "json_data.is_quote_status"
]

# for the nested thing-didnt really get it but it works :)
def get_nested_field(data, field_path):
    keys = field_path.split('.')
    for key in keys:
        data = data.get(key)
        if data is None:
            return None
    return data

# Connect to MongoDB
client = MongoClient(mongo_uri)
db = client[database_name]
source_collection = db[source_collection_name]
target_collection = db[target_collection_name]

# Loop through each document in the source collection
cursor = source_collection.find()
for doc in cursor:
    # Create a new document with only the specified fields
    new_doc = {field: get_nested_field(doc, field) for field in fields_to_extract}
    new_doc["_id"] = doc["_id"]  # Keep the original _id
    
    # Insert the new document into the target collection
    target_collection.insert_one(new_doc)

client.close()
print("Data successfully transferred to new collections.")

# ignore all .a files
*.a

# but do track lib.a, even though you're ignoring .a files above
!lib.a

# only ignore the TODO file in the current directory, not subdir/TODO
/TODO

# ignore all files in any directory named build
build/

# ignore doc/notes.txt, but not doc/server/arch.txt
doc/*.txt

# ignore all .pdf files in the doc/ directory and any of its subdirectories
doc/**/*.pdf

git rm --cached FILENAME

touch .gitignore

#include "DHT.h"

#define DHTPIN 2  // GPIO Pin D4  

#define DHTTYPE DHT11

// DHT Class dht Object with parameters - assigned Pin and DHt Type

DHT dht(DHTPIN, DHTTYPE);

void setup() {

  // Begin - start communicating with monitor - with Baud rate 9600 serial commn

  Serial.begin(9600);

  // Display test message 

  Serial.println(F("DHTxx test!"));

  dht.begin();

}

void loop() {

  

// 2000 ms - 2 Sec gap for display 

  delay(2000);

  // Read humidity and put in h

  float h = dht.readHumidity();

    // read temperature and put in t in clecius , if nothing in brackets default -False indicating Celcius

  float t = dht.readTemperature();

  // Read temperature as Fahrenheit (isFahrenheit = true)

  //read temperature and put in f in clecius , if true in brackets default -False is overwritten  indicating farenheit

  float f = dht.readTemperature(true);

  // Check if any reads failed and exit early (to try again).

  if (isnan(h) || isnan(t) || isnan(f)) {

    Serial.println(F("Failed to read from DHT 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(" ");

}

int Led Pin =2;    // D4 Pin also refereed as pin no2 in Node MCU 

void setup() 

{   

    pinMode(LedPin, OUTPUT);

    Serial.begin(9600);   

}

void loop() {

digitalWrite(LedPin, HIGH); 

delay(1000); 

digitalWrite(LedPin, LOW); 

delay(1000);              

}

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);

DIAGRAM

#include "DHT.h"

#define DHTPIN 2 

#define DHTTYPE DHT11

// DHT Class dht Object with parameters - assigned Pin and DHt Type

DHT dht(DHTPIN, DHTTYPE);

void setup() {

  // Begin - start communicating with monitor - with Baud rate 9600 serial commn

  Serial.begin(9600);

  // Display test message 

  Serial.println(F("DHTxx test!"));

  dht.begin();

}

void loop() {

  

// 2000 ms - 2 Sec gap for display 

  delay(2000);

  // Read humidity and put in h

  float h = dht.readHumidity();

    // read temperature and put in t in clecius , if nothing in brackets default -False indicating Celcius

  float t = dht.readTemperature();

  // Read temperature as Fahrenheit (isFahrenheit = true)

  //read temperature and put in f in clecius , if true in brackets default -False is overwritten  indicating farenheit

  float f = dht.readTemperature(true);

  // Check if any reads failed and exit early (to try again).

  if (isnan(h) || isnan(t) || isnan(f)) {

    Serial.println(F("Failed to read from DHT 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(" ");

}

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

}

DIAGRAM

int trig=12;

int echo=11;

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(11,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);

}

int trig=12;
int echo=11;
float duration,dist_cm,dist_in;
void setup() {
  // put your setup code here, to run once:
  pinMode(trig,OUTPUT);
  pinMode(echo,INPUT);
  Serial.begin(9600);
}

void loop() {
    // put your main code here, to run repeatedly:
    digitalWrite(trig,LOW);
    delayMicroseconds(2);
    digitalWrite(trig,HIGH);
    delayMicroseconds(10);
    digitalWrite(trig,LOW);
    
    duration=pulseIn(echo,HIGH);
    dist_cm=duration*0.0343/2.0;
    dist_in=duration*0.0315/2.0;
    Serial.print("Distance : ");
    Serial.print(dist_cm);
    Serial.print("cm/");
    Serial.print(dist_in);
    Serial.print("inches\n");
    delay(300);
}

#include "DHT.h"
 
#define DHTPIN 2  // GPIO Pin D4  
#define DHTTYPE DHT11
 
// DHT Class dht Object with parameters - assigned Pin and DHt Type
DHT dht(DHTPIN, DHTTYPE);
void setup() {
  // Begin - start communicating with monitor - with Baud rate 9600 serial commn
  Serial.begin(9600);
 
  // Display test message 
  Serial.println(F("DHTxx test!"));
  dht.begin();
}
 
void loop() {
  
// 2000 ms - 2 Sec gap for display 
  delay(2000);
 
  // Read humidity and put in h
  float h = dht.readHumidity();
    // read temperature and put in t in clecius , if nothing in brackets default -False indicating Celcius
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  //read temperature and put in f in clecius , if true in brackets default -False is overwritten  indicating farenheit
  float f = dht.readTemperature(true);
 
  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT 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(" ");
}

int Led Pin =2;    // D4 Pin also refereed as pin no2 in Node MCU 
void setup() 
{   
    pinMode(LedPin, OUTPUT);
    Serial.begin(9600);   
}
void loop() {
digitalWrite(LedPin, HIGH); 
delay(1000); 
digitalWrite(LedPin, LOW); 
delay(1000);              
}

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
}

public class GenericsInJava
{
static void processElements(ArrayList<? extends Number> a)
{
for (Object element : a)
{
System.out.println(element);
}
}

public static void main(String[] args)
{
//ArrayList Containing Integers

ArrayList<Integer> a1 = new ArrayList<>();

a1.add(10);

a1.add(20);

a1.add(30);

processElements(a1);

//Arraylist containing Doubles

ArrayList<Double> a2 = new ArrayList<>();

a2.add(21.35);

a2.add(56.47);

a2.add(78.12);

processElements(a2);

//Arraylist containing Strings

ArrayList<String> a3 = new ArrayList<>();

a3.add("One");

a3.add("Two");

a3.add("Three");

//This will not work

processElements(a3);     //Compile time error
}
}

@FunctionalInterface
interface StringReverser {
    String reverse(String str);
}

public class StringReverseLambda {
    public static void main(String[] args) {
        // Lambda expression to reverse a string
        StringReverser reverser = (str) -> new StringBuilder(str).reverse().toString();

        // Example string
        String input = "Hello, World!";
        
        // Reverse the string and print the result
        String reversed = reverser.reverse(input);
        System.out.println("Original: " + input);
        System.out.println("Reversed: " + reversed);
    }
}

import java.util.LinkedList;

class GenericStack<T> {
    private LinkedList<T> stack;

    // Constructor
    public GenericStack() {
        stack = new LinkedList<>();
    }

    // Push method to add an element to the stack
    public void push(T value) {
        stack.addFirst(value);
    }

    // Pop method to remove and return the top element of the stack
    public T pop() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty");
        }
        return stack.removeFirst();
    }

    // Peek method to return the top element without removing it
    public T peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty");
        }
        return stack.getFirst();
    }

    // Check if the stack is empty
    public boolean isEmpty() {
        return stack.isEmpty();
    }

    // Get the size of the stack
    public int size() {
        return stack.size();
    }
}

public class GenericStackDemo {
    public static void main(String[] args) {
        // Integer stack
        GenericStack<Integer> intStack = new GenericStack<>();
        intStack.push(1);
        intStack.push(2);
        intStack.push(3);
        System.out.println("Top of Integer stack: " + intStack.peek());
        System.out.println("Pop from Integer stack: " + intStack.pop());
        System.out.println("Size of Integer stack: " + intStack.size());

        // Double stack
        GenericStack<Double> doubleStack = new GenericStack<>();
        doubleStack.push(1.1);
        doubleStack.push(2.2);
        doubleStack.push(3.3);
        System.out.println("Top of Double stack: " + doubleStack.peek());
        System.out.println("Pop from Double stack: " + doubleStack.pop());
        System.out.println("Size of Double stack: " + doubleStack.size());

        // String stack
        GenericStack<String> stringStack = new GenericStack<>();
        stringStack.push("Hello");
        stringStack.push("World");
        System.out.println("Top of String stack: " + stringStack.peek());
        System.out.println("Pop from String stack: " + stringStack.pop());
        System.out.println("Size of String stack: " + stringStack.size());
    }
}

import java.util.ArrayList;

class GenericStack<T> {
    private ArrayList<T> stack;

    // Constructor
    public GenericStack() {
        stack = new ArrayList<>();
    }

    // Push method to add an element to the stack
    public void push(T value) {
        stack.add(value);
    }

    // Pop method to remove and return the top element of the stack
    public T pop() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty");
        }
        return stack.remove(stack.size() - 1);
    }

    // Peek method to return the top element without removing it
    public T peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty");
        }
        return stack.get(stack.size() - 1);
    }

    // Check if the stack is empty
    public boolean isEmpty() {
        return stack.isEmpty();
    }

    // Get the size of the stack
    public int size() {
        return stack.size();
    }
}

public class GenericStackDemo {
    public static void main(String[] args) {
        // Integer stack
        GenericStack<Integer> intStack = new GenericStack<>();
        intStack.push(1);
        intStack.push(2);
        intStack.push(3);
        System.out.println("Top of Integer stack: " + intStack.peek());
        System.out.println("Pop from Integer stack: " + intStack.pop());
        System.out.println("Size of Integer stack: " + intStack.size());

        // Double stack
        GenericStack<Double> doubleStack = new GenericStack<>();
        doubleStack.push(1.1);
        doubleStack.push(2.2);
        doubleStack.push(3.3);
        System.out.println("Top of Double stack: " + doubleStack.peek());
        System.out.println("Pop from Double stack: " + doubleStack.pop());
        System.out.println("Size of Double stack: " + doubleStack.size());

        // String stack
        GenericStack<String> stringStack = new GenericStack<>();
        stringStack.push("Hello");
        stringStack.push("World");
        System.out.println("Top of String stack: " + stringStack.peek());
        System.out.println("Pop from String stack: " + stringStack.pop());
        System.out.println("Size of String stack: " + stringStack.size());
    }
}

import java.util.ArrayList;

class GenericQueue<T> {
    private ArrayList<T> queue;

    // Constructor
    public GenericQueue() {
        queue = new ArrayList<>();
    }

    // Enqueue method to add an element to the end of the queue
    public void enqueue(T value) {
        queue.add(value);
    }

    // Dequeue method to remove and return the front element of the queue
    public T dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return queue.remove(0);
    }

    // Peek method to return the front element without removing it
    public T peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return queue.get(0);
    }

    // Check if the queue is empty
    public boolean isEmpty() {
        return queue.isEmpty();
    }

    // Get the size of the queue
    public int size() {
        return queue.size();
    }
}

public class GenericQueueDemo {
    public static void main(String[] args) {
        // Integer queue
        GenericQueue<Integer> intQueue = new GenericQueue<>();
        intQueue.enqueue(1);
        intQueue.enqueue(2);
        intQueue.enqueue(3);
        System.out.println("Front of Integer queue: " + intQueue.peek());
        System.out.println("Dequeue from Integer queue: " + intQueue.dequeue());
        System.out.println("Size of Integer queue: " + intQueue.size());

        // Double queue
        GenericQueue<Double> doubleQueue = new GenericQueue<>();
        doubleQueue.enqueue(1.1);
        doubleQueue.enqueue(2.2);
        doubleQueue.enqueue(3.3);
        System.out.println("Front of Double queue: " + doubleQueue.peek());
        System.out.println("Dequeue from Double queue: " + doubleQueue.dequeue());
        System.out.println("Size of Double queue: " + doubleQueue.size());

        // String queue
        GenericQueue<String> stringQueue = new GenericQueue<>();
        stringQueue.enqueue("Hello");
        stringQueue.enqueue("World");
        System.out.println("Front of String queue: " + stringQueue.peek());
        System.out.println("Dequeue from String queue: " + stringQueue.dequeue());
        System.out.println("Size of String queue: " + stringQueue.size());
    }
}

@FunctionalInterface
interface PiProvider {
    double getPi();
}

public class PiLambda {
    public static void main(String[] args) {
        // Lambda expression to return the value of Pi
        PiProvider piProvider = () -> Math.PI;
        
        // Invoke the lambda expression and print the value of Pi
        double piValue = piProvider.getPi();
        System.out.println("The value of Pi is: " + piValue);
    }
}

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;
import java.util.Map;

public class CollectionDemo {
    public static void main(String[] args) {
        // HashMap demonstration
        System.out.println("HashMap:");
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Alice", 25);
        hashMap.put("Bob", 30);
        hashMap.put("Charlie", 35);
        for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // LinkedHashMap demonstration
        System.out.println("\nLinkedHashMap:");
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("Alice", 25);
        linkedHashMap.put("Bob", 30);
        linkedHashMap.put("Charlie", 35);
        for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // TreeMap demonstration
        System.out.println("\nTreeMap:");
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Alice", 25);
        treeMap.put("Bob", 30);
        treeMap.put("Charlie", 35);
        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}