Snippets Collections
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
#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());
        }
    }
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class IteratorExample {
    public static void main(String[] args) {
        // Create an ArrayList and add some elements
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Cherry");

        // Create a LinkedList and add some elements
        List<String> linkedList = new LinkedList<>();
        linkedList.add("Dog");
        linkedList.add("Elephant");
        linkedList.add("Frog");

        // Iterate over the ArrayList
        System.out.println("ArrayList elements:");
        Iterator<String> arrayListIterator = arrayList.iterator();
        while (arrayListIterator.hasNext()) {
            String element = arrayListIterator.next();
            System.out.println(element);
        }

        // Iterate over the LinkedList
        System.out.println("\nLinkedList elements:");
        Iterator<String> linkedListIterator = linkedList.iterator();
        while (linkedListIterator.hasNext()) {
            String element = linkedListIterator.next();
            System.out.println(element);
        }
    }
}
class ArrayStack<T> {
    private T[] array;
    private int top;
    private int capacity;

    // Constructor
    @SuppressWarnings("unchecked")
    public ArrayStack(int capacity) {
        this.capacity = capacity;
        this.array = (T[]) new Object[capacity]; // Create a generic array
        this.top = -1;
    }

    // Push method
    public void push(T value) {
        if (top == capacity - 1) {
            throw new StackOverflowError("Stack is full");
        }
        array[++top] = value;
    }

    // Pop method
    public T pop() {
        if (top == -1) {
            throw new IllegalStateException("Stack is empty");
        }
        return array[top--];
    }

    // Peek method
    public T peek() {
        if (top == -1) {
            throw new IllegalStateException("Stack is empty");
        }
        return array[top];
    }

    // Check if stack is empty
    public boolean isEmpty() {
        return top == -1;
    }

    // Check if stack is full
    public boolean isFull() {
        return top == capacity - 1;
    }
}

public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack<Integer> intStack = new ArrayStack<>(5);
        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());

        ArrayStack<Double> doubleStack = new ArrayStack<>(5);
        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());

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









class LinkedListStack<T> {
    private static class Node<T> {
        private T data;
        private Node<T> next;

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

    private Node<T> top;

    // Push method
    public void push(T value) {
        Node<T> newNode = new Node<>(value);
        newNode.next = top;
        top = newNode;
    }

    // Pop method
    public T pop() {
        if (top == null) {
            throw new IllegalStateException("Stack is empty");
        }
        T value = top.data;
        top = top.next;
        return value;
    }

    // Peek method
    public T peek() {
        if (top == null) {
            throw new IllegalStateException("Stack is empty");
        }
        return top.data;
    }

    // Check if stack is empty
    public boolean isEmpty() {
        return top == null;
    }
}

public class LinkedListStackDemo {
    public static void main(String[] args) {
        LinkedListStack<Integer> intStack = new LinkedListStack<>();
        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());

        LinkedListStack<Double> doubleStack = new LinkedListStack<>();
        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());

        LinkedListStack<String> stringStack = new LinkedListStack<>();
        stringStack.push("Hello");
        stringStack.push("World");
        System.out.println("Top of String stack: " + stringStack.peek());
        System.out.println("Pop from String stack: " + stringStack.pop());
    }
}
public class p5b {
    static class LinkedListQueue<T> {
        private class Node<T> {
            private T data;
            private Node<T> next;

            Node(T data) {
                this.data = data;
            }
        }

        private Node<T> front, rear;

        void enqueue(T item) {
            Node<T> newNode = new Node<>(item);
            if (tail == null)
                front = rear = newNode;
            else {
                rear.next = newNode;
                rear = newNode;
            }
        }

        T dequeue() {
            if (front == null)
                System.out.println("Queue is empty");
            T data = front.data;
            front = front.next;
            if (front == null)
                rear = null;
            return data;
        }
    }

    static class ArrayQueue<T> {
        private T[] array;
        private int front, rear, capacity;

        @SuppressWarnings("unchecked")
        ArrayQueue(int size) {
            capacity = size;
            array = (T[]) new Object[capacity];
        }

        void enqueue(T item) {
            if ((rear + 1) % capacity == front)
                System.out.println("Queue is full");
            array[rear] = item;
            rear = (rear + 1) % capacity;
        }

        T dequeue() {
            if (front == rear)
                System.out.println("Queue is empty");
            T item = array[front];
            front = (front + 1) % capacity;
            return item;
        }
    }

    public static void main(String[] args) {
        ArrayQueue<Integer> intQueue = new ArrayQueue<>(5);
        intQueue.enqueue(10);
        intQueue.enqueue(20);
        System.out.println(intQueue.dequeue());
        System.out.println(intQueue.dequeue());
        LinkedListQueue<String> stringQueue = new LinkedListQueue<>();
        stringQueue.enqueue("Hello");
        stringQueue.enqueue("World");
        System.out.println(stringQueue.dequeue());
    }
}
import java.util.TreeSet;
class TreeNode{
    int value;
    TreeNode right,left;
    TreeNode(int a){
        value=a;
    }
}
class BSTTest{
    TreeNode root;
    void insert(int value)
    {
        root=insertNode(root,value);
    }
    TreeNode insertNode(TreeNode root,int value)
    {
        if(root==null)
            return new TreeNode(value);
        if(root.value>value)
            root.left=insertNode(root.left,value);
        else if(root.value<value)
            root.right=insertNode(root.right,value);
        return root;
    }
    void inorder(){
        inorderNodes(root);
        System.out.println(" ");
    }
    void inorderNodes(TreeNode root)
    {
        if(root!=null)
        {
            inorderNodes(root.left);
            System.out.print(root.value+" ");
            inorderNodes(root.right);
        }
    }
    void preorder(){
        preorderNodes(root);
        System.out.println(" ");
    }
    void preorderNodes(TreeNode root)
    {
        if(root!=null)
        {
            System.out.print(root.value+" ");
            preorderNodes(root.left);
            preorderNodes(root.right);
        }
    }
    void postorder(){
        postorderNodes(root);
        System.out.println(" ");
    }
    void postorderNodes(TreeNode root)
    {
        if(root!=null)
        {
            postorderNodes(root.left);
            postorderNodes(root.right);
            System.out.print(root.value+" ");
        }
    }
    public static void main(String[] args)
    {
        BSTTest tree = new BSTTest();
        TreeSet ts=new TreeSet();
        int[] values={10,58,42,63,15,0,42,14};
        for(int a:values)
        {
            tree.insert(a);
            ts.add(a);
        }
        System.out.println("Inorder traversals");
        tree.inorder();
        System.out.println("preorder traversals");
        tree.preorder();
        System.out.println("postorder traversals");
        tree.postorder();
    }
}
class Demo<K extends Comparable<K>, V> {
    private class Node {
        K key;
        V value;
        int height;
        Node left, right;

        Node(K key, V value) {
            this.key = key;
            this.value = value;
            this.height = 1;
        }
    }

    private Node root;

    // Utility function to get the height of the tree
    private int height(Node node) {
        if (node == null) return 0;
        return node.height;
    }

    // Utility function to get the maximum of two integers
    private int max(int a, int b) {
        return (a > b) ? a : b;
    }

    // Right rotate subtree rooted with y
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node T2 = x.right;

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

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

        // Return new root
        return x;
    }

    // Left rotate subtree rooted with x
    private Node leftRotate(Node x) {
        Node y = x.right;
        Node T2 = y.left;

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

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

        // Return new root
        return y;
    }

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

    // Insert a node
    public void insert(K key, V value) {
        root = insertNode(root, key, value);
    }

    private Node insertNode(Node node, K key, V value) {
        // 1. Perform the normal BST insertion
        if (node == null) return new Node(key, value);

        if (key.compareTo(node.key) < 0) {
            node.left = insertNode(node.left, key, value);
        } else if (key.compareTo(node.key) > 0) {
            node.right = insertNode(node.right, key, value);
        } else {
            // Duplicate keys are not allowed
            return node;
        }

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

        // 3. Get the balance factor of this ancestor node to check whether this node became unbalanced
        int balance = getBalance(node);

        // If this node becomes unbalanced, then there are 4 cases

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

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

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

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

        // Return the (unchanged) node pointer
        return node;
    }

    // Method to print tree in order
    public void inorder() {
        inorderRec(root);
    }

    private void inorderRec(Node root) {
        if (root != null) {
            inorderRec(root.left);
            System.out.print(root.key + " ");
            inorderRec(root.right);
        }
    }

    public static void main(String[] args) {
        Demo<Integer, String> tree = new Demo<>();

        /* Constructing tree given in the above figure */
        tree.insert(9, "Nine");
        tree.insert(5, "Five");
        tree.insert(10, "Ten");
        tree.insert(0, "Zero");
        tree.insert(6, "Six");
        tree.insert(11, "Eleven");
        tree.insert(-1, "Minus One");
        tree.insert(1, "One");
        tree.insert(2, "Two");

        

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

        /* The AVL Tree after deletion of 10
                 1
                /  \
               0    9
             /     /  \
           -1     5     11
                /  \
               2    6
        */
    }
}
import java.util.*;
import java.util.stream.Collectors;

class Product {
    int id;
    String name;
    double price;
    String type;
    double rating;

    Product(int id, String name, double price, String type, double rating) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.type = type;
        this.rating = rating;
    }

    public String toString() {
        return name + " (Price: " + price + ", Type: " + type + ", Rating: " + rating + ")";
    }
}

public class p11 {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
                new Product(1, "Laptop", 1500.0, "Electronics", 4.5),
                new Product(2, "Smartphone", 800.0, "Electronics", 4.8),
                new Product(3, "Refrigerator", 2000.0, "Home Appliances", 4.2),
                new Product(4, "TV", 300.0, "Electronics", 3.9),
                new Product(5, "Blender", 150.0, "Home Appliances", 4.1));

        System.out.println("Products with rating between 4 and 5:");
        products.stream().filter(p -> p.rating >= 4 && p.rating <= 5).forEach(System.out::println);

        System.out.println("\nFirst 2 products with price > 1000:");
        products.stream().filter(p -> p.price > 1000).limit(2).forEach(System.out::println);

        System.out.println("\nNumber of products under each type:");
        products.stream().collect(Collectors.groupingBy(p -> p.type, Collectors.counting()))
                .forEach((type, count) -> System.out.println(type + ": " + count));

        double averageRating = products.stream().filter(p -> p.type.equals("Electronics"))
                .mapToDouble(p -> p.rating).average().orElse(0.0);
        System.out.println("\nAverage rating of Electronics products: " + averageRating);
    }
}
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

class Person {
    private String name;
    private int age;
    private double income;

    public Person(String name, int age, double income) {
        this.name = name;
        this.age = age;
        this.income = income;
    }

    public int getAge() {
        return age;
    }

    public double getIncome() {
        return income;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", income=" + income + '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        Set<Person> setA = new HashSet<>();
        Set<Person> setB = new HashSet<>();
        Set<Person> setC = new HashSet<>();

        // Reading set A of persons from the user
        System.out.println("Enter the number of persons in set A:");
        int n = scanner.nextInt();
        scanner.nextLine(); // Consume newline
        for (int i = 0; i < n; i++) {
            System.out.println("Enter details for person " + (i + 1) + " (name, age, income):");
            String[] details = scanner.nextLine().split("\\s+");
            String name = details[0];
            int age = Integer.parseInt(details[1]);
            double income = Double.parseDouble(details[2]);
            setA.add(new Person(name, age, income));
        }

        // Computing set B of persons whose age >= 60
        for (Person person : setA) {
            if (person.getAge() >= 60) {
                setB.add(person);
            }
        }

        // Computing set C of persons whose income < 10000
        for (Person person : setA) {
            if (person.getIncome() < 10000) {
                setC.add(person);
            }
        }

        // Computing set B union C
        Set<Person> setBC = new HashSet<>(setB);
        setBC.addAll(setC);

        // Printing the computed sets
        System.out.println("\nSet B (Persons aged 60 or above):");
        printSet(setB);
        System.out.println("\nSet C (Persons with income < 10000):");
        printSet(setC);
        System.out.println("\nSet B union C:");
        printSet(setBC);
    }

    private static void printSet(Set<Person> set) {
        for (Person person : set) {
            System.out.println(person);
        }
    }
}
// Lưu dữ liệu đã chỉnh sửa vào localStorage
function saveAdData(selector) {
    const element = document.querySelector(selector);
    if (element) {
        const content = element.innerHTML;
        localStorage.setItem('adContent', content);
        alert('Đã lưu dữ liệu chỉnh sửa thành công!');
    } else {
        alert('Không tìm thấy phần tử để lưu dữ liệu.');
int maxSubArray(vector<int>& nums)
{
    int sum=0;
    int maxi = INT_MIN;
    for(int i=0;i<nums.size();++i)
    {   sum+=nums[i];
        maxi = max(maxi,sum);
        if(sum<0)
        sum=0;
    }
    return maxi;
}
  const taskForm = document.querySelector("#task-form");
const inputTask = document.querySelector("#task");
const mainCollection = document.querySelector(".collection");
const clearTask = document.querySelector(".clear-tasks");

// Function to save tasks to local storage
function saveTasksToLocalStorage(tasks) {
    localStorage.setItem('tasks', JSON.stringify(tasks));
}

// Function to load tasks from local storage
function loadTasksFromLocalStorage() {
    const tasks = JSON.parse(localStorage.getItem('tasks')) || [];
    tasks.forEach(function(task) {
        addTaskToList(task);
    });
    return tasks;
}

// Load tasks from local storage when the page loads
let tasks = loadTasksFromLocalStorage();

// Event listener for form submission
taskForm.addEventListener("submit", function(e){
    e.preventDefault();

    const inputValue = inputTask.value.trim();
    if(!inputValue){
        alert("Fill the input field");
        return;
    }

    addTaskToList(inputValue);
    tasks.push(inputValue);
    saveTasksToLocalStorage(tasks);
    inputTask.value = "";
});

// Function to add task to the list
function addTaskToList(taskContent) {
    const liElement = document.createElement("li");
    liElement.className = "collection-item";
    liElement.innerHTML = `
        <span class="task-text">${taskContent}</span>
        <a href="#" class="delete-item secondary-content">
            <i class="fa fa-remove"></i>
        </a>
        <a href="#" class="edit-item secondary-content">
            <i class="fa fa-edit"></i>
        </a>`;
   
    mainCollection.appendChild(liElement);
}

// Event listener for clearing tasks
clearTask.addEventListener("click", function(e){
    e.preventDefault();
    if(confirm("Are You Sure")){
        mainCollection.innerHTML = "";
        tasks = [];
        saveTasksToLocalStorage(tasks);
    }
});

// Event listener for editing and deleting tasks
mainCollection.addEventListener("click", function(e){
    e.preventDefault();
    const currentClickElement = e.target;

    // Editing task
    if (currentClickElement.classList.contains("fa-edit")) {
        const listItem = currentClickElement.parentElement.parentElement;
        const taskTextElement = listItem.querySelector(".task-text");
        const newTaskText = prompt("Edit Task:", taskTextElement.textContent.trim());
        if (newTaskText !== null) {
            taskTextElement.textContent = newTaskText;
            const index = tasks.indexOf(taskTextElement.textContent);
            tasks[index] = newTaskText;
            saveTasksToLocalStorage(tasks);
        }
    }

    // Deleting task
    if(currentClickElement.classList.contains("fa-remove")){
        const listItem = currentClickElement.parentElement.parentElement;
        if(confirm(`Are You Sure You Want To Remove This Task`)){
            listItem.remove();
            const index = tasks.indexOf(listItem.querySelector(".task-text").textContent);
            tasks.splice(index, 1);
            saveTasksToLocalStorage(tasks);
        };
    }
});
int maxSubArray(vector<int>& nums)
 {
    int n=nums.size();
    if(n==1)
    return nums[0];
    vector<int> pf;
    pf.push_back(nums[0]);
    for(int i=1;i<n;++i)
    pf.push_back(nums[i]+pf[i-1]);
    int m = INT_MIN;
    int elem = *max_element(pf.begin(),pf.end());
    for(int j=0;j<n-1;++j)
    {
        for(int k=j+1;k<n;++k)
        m = max(m,(pf[k]-pf[j]));
        
    }
    m = max(m,elem);
    int mi = *max_element(nums.begin(),nums.end());
    cout<<m<<" "<<mi;
    
    if(mi>m)
    return mi;
    else return m;
    

 }
javascript: (function () {
  const input = prompt("input", document.getSelection().toString());
  if (input) {
    const output = input.replace(/[\u0300\u0301]/g, "");
    window.alert(output);
    navigator.clipboard.writeText(output);
  }
})();
1) Hugeivons Pro
2) Boxicons
3) Tablet Icons
4) Font Awesome 
5) Phosphor Icons
6) Iconify
7) Flaticons
8) Lucide.dev
9) Heroicons
10) React-icons
11) Iconbuddy
12) icones.js.org
1. Nodejs & NVM
2. DBeaver
3. Postman
4. Hoppscotch - directly go to website. No package installation required 
5. Git
6. VS Code
7. Neovim
8. ThisCodeWorks PWA for PC
9. Docker Desktop 
10. Pomofocus ---- web app
11. Powertoys for windows
12. Devtoys for windows
13. python - sometimes it is needed for installing other packages in windows
14. Anaconda python version manager
15. Easy window switcher
16. QuickLook
17. Hack-N-Peck
18. WinScp
Node npm packages
1)mysql2
2)multer
3)ejs
4)nodemon
5)body-parser
6)express
7)express-session
8)connect -mongodb-session 
9)bcryptjs for encrypting password in db
10)csurf for prevention of csrf attack 
11)Express validator 
12)Xlsx for reading Excel files
13)Morgan = error logging tool
14)Axios-retry
15)pm2
16)Helmet = for production headers
17)Compression = search nodejs compression or express compression 
18)New Relic and datadog for logging and monitoring 
19)express-rate-limit
20)cookie-parser
21)jsonwebtoken
22)cors
23)dotenv

Dev
@types/bcrypt
@types/cookie-parser
@types/cors
@types/express
@types/jsonwebtoken
rimraf
ts-node-dev
typescript

React
1) Zod = validation library 
2) Tanstack react-query
3) Shadcdn
4) react hook forms
5) cn
6) tailwind prettier
7) luxon = time library
8) mockaroo.com for generating dummy data jason.
9) date-fns or dayJS= dates library 
10)React-leaflet for maps and it needs LEAFLET a js dependency.
11)react-hot-toast = alert notification toast 
12)Sentry = error logging tool
13)react-window
14)googlemaps
15)mapbox
16)deck.gl
17)Turf = geospatial 
19)Radix UI
20)react-redux & @redux/toolkit
21)popper - https://popper.js.org/docs/v2/
22)react-error-boundry


Library for charts
1)Apex charts
2)Apache echarts
3)D3.js
4)recharts
5)chartsjs
6)nivo.rocks - this is built on top of D3JS

YouTube suggestions 
1)Nextdns.io
2)Warp cli ai
3)Tmux
4)Local Https and caddy server
5)Eyedropper api for colour selection 


star

Wed May 29 2024 01:20:20 GMT+0000 (Coordinated Universal Time)

@login

star

Wed May 29 2024 01:20:03 GMT+0000 (Coordinated Universal Time)

@login

star

Wed May 29 2024 01:19:41 GMT+0000 (Coordinated Universal Time)

@login

star

Wed May 29 2024 01:19:07 GMT+0000 (Coordinated Universal Time)

@login

star

Wed May 29 2024 01:16:37 GMT+0000 (Coordinated Universal Time)

@login

star

Wed May 29 2024 01:09:41 GMT+0000 (Coordinated Universal Time)

@RahmanM

star

Wed May 29 2024 00:02:10 GMT+0000 (Coordinated Universal Time) https://salak-bouw.nl/wp-admin/themes.php?page

@radeguzvic #undefined

star

Tue May 28 2024 23:21:01 GMT+0000 (Coordinated Universal Time)

@davidmchale #counter #css

star

Tue May 28 2024 22:54:02 GMT+0000 (Coordinated Universal Time)

@ayushg103 #c++

star

Tue May 28 2024 22:32:51 GMT+0000 (Coordinated Universal Time) https://www.tensorflow.org/

@calazar23

star

Tue May 28 2024 22:21:18 GMT+0000 (Coordinated Universal Time)

@ayushg103 #c++

star

Tue May 28 2024 21:55:39 GMT+0000 (Coordinated Universal Time)

@ayushg103 #c++

star

Tue May 28 2024 21:39:14 GMT+0000 (Coordinated Universal Time)

@madgakantara

star

Tue May 28 2024 21:37:36 GMT+0000 (Coordinated Universal Time)

@madgakantara

star

Tue May 28 2024 21:33:09 GMT+0000 (Coordinated Universal Time)

@madgakantara

star

Tue May 28 2024 21:24:40 GMT+0000 (Coordinated Universal Time) https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_ignoring

@calazar23

star

Tue May 28 2024 21:22:28 GMT+0000 (Coordinated Universal Time) https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files

@calazar23

star

Tue May 28 2024 21:14:04 GMT+0000 (Coordinated Universal Time) https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files

@calazar23

star

Tue May 28 2024 17:14:11 GMT+0000 (Coordinated Universal Time)

@user21

star

Tue May 28 2024 17:12:57 GMT+0000 (Coordinated Universal Time)

@user21

star

Tue May 28 2024 17:11:44 GMT+0000 (Coordinated Universal Time)

@user21

star

Tue May 28 2024 17:10:00 GMT+0000 (Coordinated Universal Time)

@user21

star

Tue May 28 2024 17:08:20 GMT+0000 (Coordinated Universal Time)

@user21

star

Tue May 28 2024 17:06:22 GMT+0000 (Coordinated Universal Time)

@user21

star

Tue May 28 2024 16:58:19 GMT+0000 (Coordinated Universal Time)

@python

star

Tue May 28 2024 16:55:32 GMT+0000 (Coordinated Universal Time)

@python

star

Tue May 28 2024 16:54:50 GMT+0000 (Coordinated Universal Time)

@python

star

Tue May 28 2024 16:53:23 GMT+0000 (Coordinated Universal Time)

@python

star

Tue May 28 2024 16:02:47 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 16:01:48 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 16:01:23 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 16:00:18 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:59:41 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:59:08 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:58:45 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:58:18 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:56:56 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:55:43 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:54:58 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:54:30 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:53:26 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:52:58 GMT+0000 (Coordinated Universal Time)

@adsj

star

Tue May 28 2024 15:37:54 GMT+0000 (Coordinated Universal Time)

@khoa11211

star

Tue May 28 2024 15:24:12 GMT+0000 (Coordinated Universal Time)

@ayushg103 #c++

star

Tue May 28 2024 15:13:01 GMT+0000 (Coordinated Universal Time)

@Muhammad_Waqar

star

Tue May 28 2024 14:58:38 GMT+0000 (Coordinated Universal Time)

@ayushg103 #c++

star

Tue May 28 2024 14:28:30 GMT+0000 (Coordinated Universal Time)

@agedofujpn #javascript

star

Tue May 28 2024 13:52:01 GMT+0000 (Coordinated Universal Time)

@StephenThevar

star

Tue May 28 2024 13:50:01 GMT+0000 (Coordinated Universal Time)

@StephenThevar

star

Tue May 28 2024 13:46:28 GMT+0000 (Coordinated Universal Time)

@StephenThevar

Save snippets that work with our extensions

Available in the Chrome Web Store Get Firefox Add-on Get VS Code extension