DEV Community: suryansh taragi

DATABASE INDEXING IN PoatgreSQL

suryansh taragi — Tue, 12 Mar 2024 10:55:12 +0000

INDEXING

In PostgreSQL, indexing is like making a cheat sheet for the database to find things faster. Imagine you have a big book (table) and you want to quickly find specific information (rows) without reading the whole book.

So, an index is like a smart bookmark. It's a quick reference guide that helps PostgreSQL find what you're looking for without going through every page of the book. When you ask the database a question (query), it checks the index first to see if it can answer your question without reading the entire table.

PostgreSQL offers different types of these bookmarks, like B-tree, hash, GiST, SP-GiST, and BRIN, each designed for specific types of questions or ways of organizing information.

But, there's a catch. Creating these bookmarks takes up extra space, and it can make adding, changing, or deleting information a bit slower. So, you need to be thoughtful about when and where to use them. It's like deciding where to put your cheat sheet - it can be super helpful, but you don't want it to get in the way of actually using the book. So, choose wisely based on the questions you often ask the database and how your data is organized.

Types Of Index

1. B-Tree

In PostgreSQL, the B-tree index is like the go-to tool for efficiently handling data. It's so handy that it's the default choice - whenever you tell PostgreSQL to create an index without specifying the type, it automatically goes for the B-tree.

Picture the B-tree index as a well-organized tree structure. At the top, there's the root node, kind of like the big boss. This boss points to other nodes, and each node has lots of key-value pairs. The keys are like labels for quick finding, and the values guide us straight to the actual data in the table.

Making a B-tree index in PostgreSQL is simple. You just use the CREATE INDEX command. Here's how you do it:

CREATE INDEX index_name ON table_name;

single column indexing

To create a B-tree index on a specific column in a table rather than indexing the entire table, you can use the following syntax:

CREATE INDEX index_name ON table_name (column_name);

Here's an example using a table named "sales_info" and inserting sample data:

CREATE TABLE sales_info (
  sales_id integer NOT NULL, 
  email VARCHAR, 
  location VARCHAR, 
  item_purchased VARCHAR, 
  price VARCHAR
);

INSERT INTO sales_info (
  sales_id, email, location, item_purchased, price
) VALUES 
  (1, 'halie46@gmail.com', 'London', 'Headphone', '$50'), 
  (2, 'romaine21@gmail.com', 'Australia', 'Webcam', '$50'), 
  (3, 'frederique19@gmail.com', 'Canada', 'iPhone 14 pro', '$1259'), 
  (4, 'kenton_macejkovic80@hotmail.com', 'London', 'Wireless Mouse', '$20'), 
  (5, 'alexis62@hotmail.com', 'Switzerland', 'Dell Charger', '$15'), 
  (6, 'concepcion_kiehn@hotmail.com', 'Canada', 'Longitech Keyboard', '$499');

To create a B-tree index on the "sales_id" column:

CREATE INDEX idx_sales_id ON sales_info (sales_id);

Creating an index on specific columns can significantly improve query performance, especially when dealing with large datasets.

Hash Index

Hash indexes are optimized for rapid key-value searches. They excel in scenarios where query conditions involve equality checks on indexed columns, offering swift data retrieval by directly mapping the hash function to the location of the desired data. Hash indexes are particularly effective for operations like = or IN, emphasizing efficiency in equality comparisons.

Similar to other index types, hash indexes require regular maintenance during data modifications (inserts, updates, and deletes) to uphold data consistency. However, it's worth noting that maintaining hash indexes can be comparatively more resource-intensive than B-tree indexes. This is attributed to the additional overhead of resolving collisions and rehashing data.

To establish a hash index in PostgreSQL, you can employ the CREATE INDEX statement with the USING HASH clause, as demonstrated below:

CREATE INDEX hash_name ON table_name USING HASH (column_name);

This command generates a hash index named "hash_name" on the specified column of the table.

It's crucial to note that while PostgreSQL supports hash indexes, they may not be the most suitable choice for range queries or sorting tasks. In such cases, B-tree indexes are typically preferred, being the default and widely used index type.

Here's an example illustrating the creation of a hash index on the "sales_id" column in the "sales_info" table:

CREATE INDEX idx_sales_id ON sales_info USING HASH(sales_id);

CREATE INDEX idx_sales_id ON sales_info USING HASH(sales_id);

EXPLAIN (ANALYZE) 
SELECT 
  * 
FROM 
  sales_info 
WHERE 
  sales_id = 5;

GiST and SP-GiST Indexes

GiST (Generalized Search Tree) and SP-GiST (Space-Partitioned Generalized Search Tree) indexes are advanced index types in PostgreSQL that provide support for a wide range of data types and search operations.

They are particularly useful for handling complex data structures and spatial data, GiST indexes are what you use if you want to speed up full-text searches.

Creating GiST and SP-GiST Indexes:

To create a GiST or SP-GiST index in PostgreSQL, you can use the CREATE INDEX statement with the USING GIST or USING SPGIST clause, respectively.

Here's an example of creating a GiST index on a geometry column:

CREATE INDEX index_geometry ON table_name USING GIST (geometry_column);

And here's an example of creating an SP-GiST index on a tsvector column:

CREATE INDEX index_text_search ON table_name USING SPGIST (tsvector_column);

MERGE CONFLICTS in GITHUB

suryansh taragi — Tue, 12 Mar 2024 10:51:00 +0000

MERGE CONFLICT

Certainly! In version control systems like Git, a merge conflict occurs when two branches have changes in the same part of a file, and Git is unable to automatically merge those changes. This can happen when two developers make changes to the same line or section of code independently. When you try to merge these branches, Git will notify you of the conflict, and it's up to you to resolve it.

Let's go through a simple example to illustrate a merge conflict and how to resolve it in a GitHub repository.

Example

Suppose you have a GitHub repository with a file called example.txt, and two branches: master and feature-branch. The example.txt file initially looks like this:

Hello, World!
This is an example file.

Now, two developers make changes to the same line in example.txt, but in different branches.

In the master branch, the file is changed to:

Hello, GitHub!
This is an example file.

In the feature-branch branch, the file is changed to:

Hello, World!
This is an updated example file.

Now, someone tries to merge the feature-branch into master:

$ git checkout master
$ git merge feature-branch

At this point, Git realizes there is a conflict. It might produce an error message, and if you open example.txt, you'll see something like:

<<<<<<< HEAD
Hello, GitHub!
=======
Hello, World!
This is an updated example file.
>>>>>>> feature-branch

The lines between <<<<<<< HEAD and ======= are from the current branch (master), and the lines between ======= and >>>>>>> feature-branch are from the branch being merged (feature-branch). Now, you need to manually resolve this conflict.

RESOLVE IN GITHUB

to resolve the conflict, edit the file to decide what the final version should be. For example:

Hello, GitHub!
This is an updated example file.

After resolving the conflict, you need to commit the changes:

$ git add example.txt
$ git commit -m "Merge branch 'feature-branch' into master"

Now, the merge conflict is resolved, and you have successfully merged the changes from feature-branch into master.

Remember, conflicts are a natural part of collaboration, and it's essential to communicate with your team to ensure that conflicts are resolved in a way that maintains the integrity of the codebase.

RESOLVE IN VSCODE

Resolving a merge conflict involves combining changes from different branches in a way that makes sense. Here's an example of how you might resolve the conflict in a way that incorporates both changes:

Hello, GitHub!
This is an updated example file.

In this resolution:

"Hello, GitHub!" is taken from the master branch.
"This is an updated example file." is taken from the feature-branch.

This resolution includes the changes from both branches to create a coherent and updated version of the file. Once you've made this decision, you would save the file and then commit the changes:

Visual Studio Code (VSCode) provides a user-friendly interface for resolving merge conflicts. Here's a step-by-step guide on how to resolve a merge conflict using VSCode:

Open the File with Conflict:
Open VSCode and navigate to the file with the conflict.
Open Source Control (Git) View:
Click on the Source Control icon in the activity bar on the side of the window. This will open the Source Control view.
1. Navigate to the Changes Tab: In the Source Control view, switch to the "Changes" tab. You should see the file with a merge conflict listed.
2. Review and Choose Changes: Click on the conflicted file to open it. You'll see the conflict markers (<<<<<<<, =======, and >>>>>>>) indicating the conflicting changes.
3. Use the "Accept Incoming" or "Accept Current" Buttons: VSCode provides buttons in the gutter (to the left of the conflicting lines) to accept either the incoming (from the branch being merged) or current (from the branch you are merging into) changes. Click the buttons as needed.
4. Manually Edit if Necessary: If you want to customize the resolution further or if the automatic resolution is not satisfactory, you can manually edit the file.
5. Mark as Resolved: Once you're satisfied with the resolution, save the file.
6. Commit the Changes: Go back to the Source Control view, stage the resolved file by clicking the "+" button next to it, and then commit the changes with a meaningful commit message.

Palindrome check(cpp)

suryansh taragi — Thu, 30 Nov 2023 14:12:00 +0000

Description of the Palindrome Checker Code:

Function isPalindrome(const string &word):

Takes a string word as input.
Creates a new string (cleanWord) by removing spaces and converting characters to lowercase for case-insensitive comparison.
Checks if the cleaned word is a palindrome.
Returns true if it is a palindrome, and false otherwise.

Main Function:
Declares a string variable userWord to store user input.
Prompts the user to enter a word.
Calls the isPalindrome function to check if the entered word is a palindrome.
Prints "YES, IT IS PALINDROME" or "NO, IT IS NOT A PALINDROME" based on the result.

Palindrome Check:

Utilizes the isPalindrome function to determine whether the entered word is a palindrome.
Palindrome checking is case-insensitive and ignores spaces.

Input and Output:

Takes user input for a word using cin.
Displays the result of the palindrome check using cout.

Palindrome Checking Logic:

Iterates through the cleaned word from both ends, comparing characters.
Returns false if any pair of characters do not match.
Returns true if all pairs match, confirming a palindrome.

Note:

The code uses a simplified method for checking palindromes, suitable for single-word inputs.
It provides a quick and straightforward way to determine if a word is a palindrome or not.
This code serves as a basic palindrome checker, allowing users to input a word and check whether it reads the same backward as forward, considering case insensitivity and ignoring spaces.

code link click here

SNAKE LADDER (cpp)

suryansh taragi — Thu, 30 Nov 2023 14:04:57 +0000

Description of the Snake and Ladder Game Code:

Function rollDice():

Generates a random number between 1 and 6, simulating a six-sided dice roll.
Returns the rolled dice value.

Function playGame():

Implements the Snake and Ladder game logic.
Initializes player positions (player1 and player2) to 0 and currentPlayer to 1 (for player 1).
Loops until one of the players reaches or exceeds position 100.
Asks players to press Enter to roll the dice and updates their positions accordingly.
Checks for snakes and ladders at specific positions, adjusting the player's position accordingly.
Switches to the next player after each turn.
Displays the current positions of both players after each turn.
Determines the winner based on who reaches or exceeds position 100 first.

Main Function:

Seeds the random number generator with the current time.
Calls playGame() to start and execute the Snake and Ladder game.

Randomness:

Utilizes the rand() function and srand(time(0)) to introduce randomness to dice rolls.

Game Features:

Incorporates snakes and ladders with specific positions affecting player movement.
Provides messages indicating snake bites or ladder discoveries during the game.

Output:

Displays information such as the rolled dice value, player positions, and game progress.

Winner Determination:

Declares the winner based on the player who reaches or exceeds position 100 first.

Note:

The code offers a simplified representation of the Snake and Ladder game without a graphical interface.
It serves as a text-based illustration of player movement, snake bites, and ladder discoveries.
This code provides a basic implementation of the classic Snake and Ladder game, showcasing player movements and the influence of snakes and ladders on the gameplay.

code link-click here

CGPA CALCULATOR

suryansh taragi — Thu, 30 Nov 2023 13:56:24 +0000

Description of the Code:

The provided C++ code converts a Cumulative Grade Point Average (CGPA) to its equivalent percentage. Here's a breakdown of the code:

Function cgpaToPercentage:

Takes a double parameter cgpa representing the Cumulative Grade Point Average.
Assumes a simple conversion formula (e.g., CGPA * 10) to calculate the equivalent percentage.
Returns the calculated percentage.

Main Function:

Declares a double variable cgpa to store the user-input CGPA.

Prompts the user to enter their CGPA.

Checks if the entered CGPA is within the valid range (0 to 10).

If valid, calls the cgpaToPercentage function to convert CGPA to percentage.
Prints the equivalent percentage.
Uses cout for output and cin for input.
If the entered CGPA is not within the valid range, prints an error message indicating an invalid CGPA.

Input Validation:

Ensures the entered CGPA is between 0 and 10.

Output:

Displays either the equivalent percentage or an error message based on the validity of the entered CGPA.

Assumption:

The code assumes a linear conversion from CGPA to percentage (CGPA * 10).
It provides a straightforward illustration of converting CGPA to a more commonly used percentage scale.

Note:

The code does not include advanced error handling or additional validation beyond the specified CGPA range.
This code offers a simple utility for students or users to quickly convert their CGPA to a percentage, assuming a direct linear relationship between the two grading systems.

github link-click here

BANK MANAGEMET SYSTEM

suryansh taragi — Thu, 30 Nov 2023 13:49:18 +0000

Class Definition (Bank):

Private members include total for customer count and id for search/update.
person array stores customer data (name, ID, address, contact, cash).
Public methods handle various banking operations.

Public Methods:

choice(): Displays a menu for user selection.
perData(): Creates a new customer account.
show(): Displays all customer details.
update(): Allows updating customer information.
search(): Searches and displays customer details.
transactions(): Handles deposit/withdrawal transactions.
del(): Removes a specific customer or clears the entire database

main() Function:

Creates a Bank instance and initiates banking operations using the choice() method.

Banking Operations:

Create New Account:
Takes user input for new customer details.
View Customers List:
Displays details of all customer accounts.
Update Information:
Allows the user to update existing customer data.
Check Details:
Searches for a customer by ID and displays their details.
Transactions:
Handles deposit and withdrawal transactions for existing customers.
Remove Existing Account:
Allows removal of a specific customer record or clears the entire database.

User Interface:

Simple text-based menu for user interaction.

Usage of conio.h and windows.h:

Utilizes conio.h for console I/O functions (getch()) and windows.h for screen clearing and delays (Sleep()).

Looping Structure:

The program runs in an infinite loop until the user chooses to exit.

Basic validation ensures proper handling of user inputs.
Structure and Organization:

Code is modular with methods, enhancing readability and organization.
Considerations for Improvement:

Suggestions include avoiding deprecated headers and enhancing error handling for a more robust system.

code link -click here

SIMPLE GAME USING PYGAME

suryansh taragi — Thu, 07 Sep 2023 11:41:06 +0000

Exploring the Universe through Code: My School Time Projects
During my school years, I had the opportunity to dive into the world of game development using Python and Pygame, and the experience was nothing short of exhilarating. I'd like to share two of my most cherished projects: "Drop Space" and "Space War Multiplayer Game," both of which allowed me to combine my passion for coding and my fascination with outer space.

1. Drop Space: A Galactic Adventure
Drop Space was the first project that truly ignited my interest in game development. In this single-player game, players controlled a spaceship navigating through an asteroid-filled galaxy. The goal was simple yet challenging: survive as long as possible by avoiding collisions with fast-moving space debris.

The game was brought to life using Python's Pygame library, which provided the tools to handle graphics, audio, and user input. It was amazing to see how code could create a visual and interactive experience that players could enjoy.

One of the most rewarding aspects of developing Drop Space was the opportunity to learn about game physics and collision detection. I was able to experiment with different algorithms to ensure that the spaceship's movements felt realistic and responsive.

2. Space War Multiplayer Game: An Intergalactic Showdown

Building on my experience with Drop Space, I decided to take on a more ambitious project: a multiplayer space battle game. In this game, two players could compete head-to-head, piloting their own spaceships and engaging in thrilling dogfights amidst a starry backdrop.

These school projects taught me that coding is not just about solving problems; it's also about creating experiences. They reinforced my belief that with determination, curiosity, and the right tools, anyone can turn their imaginative ideas into interactive realities.

As I look back on my school time projects, I am grateful for the skills and insights I gained through them. They were not just games; they were journeys into the boundless universe of programming and game development.

Now, armed with the knowledge and passion I've acquired, I'm excited to explore new galaxies and create even more captivating experiences in the world of game development.

here is the github link for those project . Try it and add some more features to it, and let me know in the comments.

Drop Space :-https://github.com/suryansh-code/python_PROJECTS/blob/master/box%20down.py

Space War :-https://github.com/suryansh-code/python_PROJECTS/blob/master/multiplayer%20space%20game

BOGO SORT

suryansh taragi — Sun, 03 Sep 2023 05:31:43 +0000

BOGO sort also known as stupid sort , slow sort ,monkey sort , shotgun sort and monkey sort . the name stupid is given to this sort because of its working ,

BOGO sort, short for "Bogosort," is a highly inefficient and humorously named sorting algorithm that serves more as a joke or a parody of sorting algorithms than a practical sorting method. In fact, it is often referred to as "stupid sort" precisely because of its absurdly inefficient nature.

Here's how Bogo sort works:

Start with an unsorted list of elements that need to be sorted.
Randomly shuffle the elements in the list.
Check if the list is sorted. If it is, stop; otherwise, go back to step 2
Repeat steps 2 and 3 until the list becomes sorted.

" my college pc crashes .when I run this algo on that pc for
around 1000 of data"

#include<bits/stdc++.h>

using namespace std;

bool isSorted(int Arr[], int N)

{

    for(int i=1; i<N; i++)

    {

        if(Arr[i] < Arr[i-1])

            return false;

    }

    return true;

}



void randomly_shuffle(int Arr[], int N)

{

    for(int i = 0; i < N; i++)

    {

        swap(Arr[i], Arr[rand() % N]);

    }

}




int main()

{

    int N = 4;

    int Arr[N] = {2, 13, 7, 1};



    // isSorted() function return true if array

    // is sorted else it returns false

    while(!isSorted(Arr, N))

    {

        // randomly_shuffle() function generates a

        // random permutation of array

        randomly_shuffle(Arr, N);

    }

    for(int i = 0; i < N; i++)

        cout << Arr[i] << " ";



    return 0;

}

TIME COMPLEXITY

Worst-case time complexity: O(infinite)

Average-case time complexity: O(n! * n) :- There are n! permutations, only one of which is sorted. So, we would expect to get the correct answer after about O(n!) iterations. And each shuffle/check operation is itself O(n)

Best-case time complexity: O(n)
When the given array is already sorted, the program terminates just after checking if the array is sorted once, which takes O(n) time to execute.

VIRTUAL ASSISTANT USING PYTHON (GUI-BASED)

suryansh taragi — Mon, 12 Sep 2022 18:35:14 +0000

VIRTUAL ASSISTANT USING PYTHON
THIS IS MY SECOND YEAR (B-TECH CSE) MINI PROJECT . THIS PROJECT JUST WORK AS THE AMAZON ALEXA AND GOOGLE ASSISTANT . BUT THE FEATURES ARE LIMITED . NO USE OF ANY AI JUST WORKS WITH (IF-ELSE) CONDITION , CAN PERFORM SOME TASKS LIKE (OPENING ANY WEBSITE OR APPLICATION , PLAYING MUSIC , SENDING EMAILS

IDEA
The best thing about this project is that this is GUI based . tkinter is a very famous library for making GUI based projects . at starting I only thought to make this project terminal based means all the output are shown in terminal. than I remember about my childhood project (A GUI TEXT GAME) so I merge both projects which in result turns out to be pretty impressive .

INTERFACE OF THIS PROJECT

SOME LIBRARIES WHICH ARE USED:-
1.random
2.tkinter
3.Pyaudio
4.pyttssx3
5.datetime
6.webbrowser
7.speech recognizer

HOW IT WORKS
1.Making a function which use our system microphone and take our voice as input.
2.Then convert the voice format to text format.
3.Perform various functions according to that input.
4.Than again convert the text output in voice format.

THIS PPT AND GIT-REPO SUMMARIZED MY PROJECT IN DETAILED
1.POWERPOINT PRESENTATION
2.GIT REPO

Thank You

CHECK THE SEQUENCE (STRICTLY DECREASING THAN INCREASING || STRICTLY DECREASING || STRICTLY INCREASING)

suryansh taragi — Mon, 12 Sep 2022 18:33:55 +0000

Check Number sequence
You are given S, a sequence of n integers i.e. S = s1, s2, ..., sn. Compute if it is possible to split S into two parts : s1, s2, ..., si and si+1, si+2, ….., sn (0 <= i <= n) in such a way that the first part is strictly decreasing while the second is strictly increasing one.
Note : We say that x is strictly larger than y when x > y.
So, a strictly increasing sequence can be 1 4 8. However, 1 4 4 is NOT a strictly increasing sequence.

That is, in the sequence if numbers are decreasing, they can start increasing at one point. And once the sequence of numbers starts increasing, they cannot decrease at any point further.
Sequence made up of only increasing numbers or only decreasing numbers is a valid sequence. So, in both the cases, print true.

You just need to print true/false. No need to split the sequence.
Input format :
Line 1 : Integer 'n'
Line 2 and Onwards : 'n' integers on 'n' lines(single integer on each line)
Output Format :
"true" or "false" (without quotes)
Constraints :
1 <= n <= 10^7
Sample Input 1 :
5
9
8
4
5
6
Sample Output 1 :
true
Sample Input 2 :
3
1
2
3
Sample Output 2 :
true
Sample Input 3 :
3
8
7
7
Sample Output 3 :
false
Explanation for Sample Format 3 :
8 7 7 is not strictly decreasing, so output is false.
Sample Input 4 :
6
8
7
6
5
8
2
Sample Output 4 :
false
Explanation for Sample Input 4 :
The series is :
8 7 6 5 8 2
It is strictly decreasing first (8 7 6 5). Then it's strictly increasing (5 8). But then it starts strictly decreasing again (8 2). Therefore, the output for this test case is 'false'

SOLUTION

#include<iostream>
using namespace std;

int main() {

    int n;
    cin>>n;
    bool a;
    int count=0;

    int num[n];

    for(int i=0;i<n;i++)
    {
        cin>>num[i];
    }


    for(int i=0;i<n;i++)
    {
        if(num[i]>num[i+1])
        {
            a=true;
            count++;
        }

        else
        {
            a=false;
            break;
        }
    }

    for(int i=count;i<n;i++)
    {
        if(num[i]<num[i+1])
        {
            a=true;
            count++;
        }

        else
        {
            a=false;
            break;
        }
    }



    for(int i=count;i<n;i++)
    {
        if(num[i]<num[i+1])
        {
            a=true;
            count++;
        }

        else
        {
            a=false;
            break;
        }
    }

    for(int i=count;i<n;i++)
    {
        if(num[i]>num[i+1])
        {
            a=true;
            count++;
        }

        else
        {
            a=false;
            break;
        }
    }

    if(a==1)
    {
        cout<<"true";
    }
    else
    {
        cout<<"false";
    }
}

suggest me a better approach to solve this problem
git

HOW TO SOLVE (N-rows ) DIAMOND PATTERN USING C++.

suryansh taragi — Fri, 09 Sep 2022 15:57:20 +0000

(N-ROWS) DIAMOND OF STARS PATTERN

loops are the most important part of any programming. to master the the concept of loops I practiced various type of pattern (Star,Alphabet,Numeric) .

This question is a last question of assignment in coding-ninjas platform .

**Print the following pattern for the given number of rows.
Note: N is always odd.

Pattern for N = 5

The dots represent spaces.
**

I divided the pattern in 4 parts the upper left,The upper right,
The bottom left and the bottom right . which makes it very easy to solve the given problem.so there are total 6 loops

the loop which count the rows of upper triangle (n+1/2) .
the loop which count the rows of bottom triangle (n/2).
the loop to print spaces for upper triangle (nested loop of upper loop).
the loop to print spaces for bottom triangle (nested loop of bottom loop).
the loop to print the * for upper triangle (nested loop of upper loop).
the loop to print the * for bottom triangle (nested loop of bottom loop).

#include<iostream>
using namespace std;
int main()
{
    int i, j, rowNum, space;
    cin>>rowNum;
    for(i=1; i<=(rowNum+1)/2; i++)
    {
        for(j=1; j<=(rowNum+1)/2-i; j++)
            cout<<" ";
        for(j=1; j<=(2*i-1); j++)
            cout<<"*";
        cout<<endl;
    }
    for(i=(rowNum/2); i>=1; i--)
    {
        for(j=1; j<=(rowNum/2)-i+1; j++)
            cout<<" ";
        for(j=1; j<=2*i-1; j++)
            cout<<"*";
        cout<<endl;
    }
    cout<<endl;
    return 0;
}

git-link