Forem: cybo-neutron

Array/Object Destructuring in JavaScript

cybo-neutron — Mon, 30 Jan 2023 11:57:48 +0000

Destructuring in js refers to unpacking of values from arrays and properties from objects into distinct variables.
Now what does this mean?

Lets say we have an array of two elements and we want to store the values in two variables.
Conventionally we would go with this approach.

const arr = [1, 3];
const a = arr[0];
const b = arr[1];

OR if we have an object and we want to get the properties from the array we will access the values using dot(.) operator

const obj = {
  name: "Naruto",
  power: "Rasengan",
};

const name = obj.name;
const power = obj.power;

Javascript introduced the concept of destructuring in ES6, which make it very easy to extract data from arrays/objects and store them in distict variables.
For the above problems we will use the following approaches.

For array

const arr = [1, 3];
const [a,b] = arr;

/*
a = 1
b = 3
*/

for object

const obj = {
  name: "Naruto",
  power: "Rasengan",
};

const { name, power } = obj;


/*
name -> Naruto
power -> Rasengan
*/

Default values

We can also assign some default values if the value we are trying to extract does not exist.


const [a, b, c = 1] = [1,3];

const { name, power,age=0 } = {name: "Naruto",
  power: "Rasengan"};

In the above example the value of c will be 1 as the array only has 2 elements and c is trying to extract 3rd element.

AND age will be 0 as age is not present in the object which is being destructured.

Priority Queue in C++

cybo-neutron — Fri, 18 Nov 2022 06:37:07 +0000

In this article we will be exploring different methods of creating a priority queue in C++ and modifying it according to our use case.

By default priority queue in C++ implements max heap. That means that the top most element will always be the greatest of all numbers present in the priority queue.

These are some of the member functions of priority queue.

Member functions

Element Access
- top -> Returns the top element of the priority_queue
Capacity
- empty -> returns true if empty
- size -> size of priority_queue
Modifiers
- push -> inserts element
- emplace -> insert element
- pop -> removes the top element

Simple example of priority queue

#include <iostream>
#include <queue>

int main()
{
    std::priority_queue<int> pq;
    // inserting elements
    pq.push(1);
    pq.push(4);
    pq.push(0);

    // Printing the elements of priority queue untill the priority queue is not empty
    while (!pq.empty()) 
    {
        int top = pq.top(); // accessing the top element of priority queue
        pq.pop();           // removing the top element of the priority queue
        std::cout << top << " ";
    }

    /*
    The elements will be printed in descending order as the priority queue by default implement max-heap.
    Output : 
        4 1 0

    */
}

Creating a Priority Queue

Creating empty priority queue

#include <queue>
int main()
{
    std::priority_queue<int> pq;

}

Creating a priority queue from a vector

std::vector<int> v{5, 6, 3, 9};

std::priority_queue<int> pq(v.begin(), v.end());

Creating a min-heap priority queue

std::vector<int> v{5, 6, 3, 9};

std::priority_queue<int, std::vector<int>, std::greater<int>> pq(v.begin(), v.end());

Creating priority queue with custom comparator

In this section we will explore all sort of different techniques of creating a priority queue using our own custom comparator.

The third template parameter should be a function pointer or a class with () overloaded.

Declaring a compare function

    int comp(int a, int b)
    {
        return a < b;
    }

    std::vector<int> v{5, 6, 3, 9};
    //Priority queue using vector
    std::priority_queue<int, std::vector<int>, decltype(&comp)> pq(v.begin(), v.end(), comp);
    //Declaring the type of function yourself. -> bool (*)(int, int)
    std::priority_queue<int, std::vector<int>, bool (*)(int, int)> pq(v.begin(), v.end(), comp);
    //Declaring using the function class template
    std::priority_queue<int, std::vector<int>, std::function<bool(int, int)>> pq(v.begin(), v.end(), comp);

    //Empty priority queue with comp as comparator
    std::priority_queue<int, std::vector<int>, decltype(&comp)> pq2(comp);

Declaring compare lambda function

NOTE : In decltype(comp) we no longer require the & operator.

auto comp = [](int a, int b)
{
    return a < b;
};

std::vector<int> v{5, 6, 3, 9};
//Using decltype
std::priority_queue<int, std::vector<int>, decltype(comp)> pq(v.begin(), v.end(), comp);
//Using function pointer
std::priority_queue<int, std::vector<int>, bool (*)(int, int)> pq(v.begin(), v.end(), comp);
//Using function class template
std::priority_queue<int, std::vector<int>, std::function<bool(int, int)>> pq(v.begin(), v.end(), comp);

std::priority_queue<int, std::vector<int>, decltype(comp)> pq2(comp);

Declaring using a compare class

Declare the class like shown below.

NOTE : You can also use struct in place of class.

class Compare
{
public:
    bool operator()(int a, int b)
    {
        return a < b;
    }
};

Use the compare class while declaring the priority queue

std::priority_queue<int, std::vector<int>, Compare> pq(v.begin(), v.end());

Now lets take an example of its use case.
We want to take out students from the priority queue based on their age.

#include <iostream>
#include <queue>
#include <vector>

struct Student
{
    std::string name;
    int age;
    int rollno;

    void print()
    {
        std::cout << name << " | " << age << " | " << rollno << "\n";
    }
};

class Compare
{
public:
    bool operator()(Student &a, Student &b)
    {
        return a.age > b.age;
    }
};

int main()
{
    std::vector<Student> students{
        Student{"Naruto", 18, 100},
        Student{"Sasuke", 19, 120},
        Student{"Rock Lee", 17, 077}};

    std::priority_queue<Student, std::vector<Student>, Compare> pq(students.begin(), students.end());

    while (!pq.empty())
    {
        auto top = pq.top();
        pq.pop();
        top.print();
    }
}
#include <iostream>
#include <queue>
#include <vector>

struct Student
{
    std::string name;
    int age;
    int rollno;

    void print()
    {
        std::cout << name << " | " << age << " | " << rollno << "\n";
    }
};

class Compare
{
public:
    bool operator()(Student &a, Student &b)
    {
        return a.age > b.age;
    }
};

int main()
{
    std::vector<Student> students{
        Student{"Naruto", 18, 100},
        Student{"Sasuke", 19, 120},
        Student{"Rock Lee", 17, 077}};

    std::priority_queue<Student, std::vector<Student>, Compare> pq(students.begin(), students.end());

    while (!pq.empty())
    {
        auto top = pq.top();
        pq.pop();
        top.print();
    }
}

/* Output

Rock Lee | 17 | 63
Naruto | 18 | 100
Sasuke | 19 | 120

*/

Basics of PostgreSQL

cybo-neutron — Wed, 16 Nov 2022 16:27:57 +0000

PostgreSQL Cheatsheet

Login to db

psql --username=<username> --dbname=postgres

Database Commands

Create Databse
```
CREATE DATABASE database_name;
```
Rename Database

   ALTER DATABASE database_name RENAME TO new_database_name;

Delete/Drop Database

   DROP DATABASE <database_name>

Shortcut commands

\l -> list all databases
\c <database_name> -> connect to database

Table commands

Create table

CREATE TABLE table_name();

CREATE TABLE table_name(column_name DATATYPE CONSTRAINTS);

Add column

ALTER TABLE table_name ADD COLUMN column_name DATATYPE;
ALTER TABLE table_name ADD COLUMN column_name DATATYPE CONSTRAINTS;
--eg : ALTER TABLE characters ADD COLUMN name VARCHAR(30)NOT NULL;

Delete column

ALTER TABLE table_name DROP COLUMN column_name;

Rename column

ALTER TABLE table_name RENAME COLUMN column_name TO new_name;

Adding Constraint to columns

--Primary key 
--You should set a primary key on every table and there can ***only be one*** per table.
ALTER TABLE table_name ADD PRIMARY KEY(column_name);
ALTER TABLE table_name ADD PRIMARY KEY(column1, column2);   --composite primary key

--Unique
ALTER TABLE table_name ADD UNIQUE(column_name);

--ALTER COLUMN FOR NOT NULL
ALTER TABLE table_name ALTER COLUMN column_name SET NOT NULL;

Drop constraint

ALTER TABLE table_name DROP CONSTRAINT constraint_name;

Insert in table

INSERT INTO table_name(column_1, column_2) VALUES(value1, value2);
--eg : INSERT INTO second_table(id,username) VALUES(1,'Samus');

-- inserting multiiple rows at once
INSERT INTO characters(name, homeland, favorite_color)
VALUES('Mario', 'Mushroom Kingdom', 'Red'),
('Luigi', 'Mushroom Kingdom', 'Green'),
('Peach', 'Mushroom Kingdom', 'Pink');

Select from table (View)

SELECT columns FROM table_name;
--eg : SELECT * FROM table_name;

SELECT columns FROM table_name ORDER BY column_name;  --showing in a specific order

Delete from table

DELETE FROM table_name WHERE condition;

Delete table
```
DROP TABLE table_name;
```
Delete all contents of table
```
TRUNCATE table_name;
```

Update table

UPDATE table_name SET column_name=new_value WHERE condition;

Foreign key

    -- creating a column and making it a foreign key
    ALTER TABLE table_name ADD COLUMN column_name DATATYPE REFERENCES referenced_table_name(referenced_column_name);

    -- making an existing column foreign key
    ALTER TABLE <table_name> ADD FOREIGN KEY(<column_name>) REFERENCES <referenced_table_name>(<referenced_column_name>);

JOIN

SELECT columns FROM table_1 FULL JOIN table_2 ON table_1.primary_key_column = table_2.foreign_key_column;

--using junction table to join 3 tables
SELECT columns FROM junction_table
    FULL JOIN table_1 ON junction_table.foreign_key_column = table_1.primary_key_column
    FULL JOIN table_2 ON junction_table.foreign_key_column = table_2.primary_key_column;

Shortcut commands

Commands	Description
`\d`	display tables
`\d <table_name>`	display information of table

Notes

Junction table
- Many-to-many" relationships usually use a junction table to link two tables together, forming two "one-to-many" relationships.
- Junction table uses primary keys from both tables as foreign key to create the relationship.
Composite Primary Key
- Primary key made from two or more columns.

    ALTER TABLE table_name ADD PRIMARY KEY(column1, column2);

Datatypes

INT
VARCHAR( )
SERIAL -> INT and NOT NULL . Automatically increase value when new row is added.
NUMERIC( , ) -> Decimal number.