## November 28, 2019

## November 26, 2019

## November 24, 2019

### #Algorithms Part 3: Shortest Path Algorithms(Bellman-Ford Algorithm)

**Bellman-Ford Algorithm**- As we have seen in above example that Dijkstra Algorithm not always find the shortest path in case of negative edges. Bellman-Ford always give correct result even in case of negative edges (though it has its own drawback).
- As Dijkstra says relax the vertices's only once, Bellman-Ford says we can relax vertices's for n number of times, so that we can get perfect shortest path to all the vertices's.
- In Bellman-Ford we make list of all the edges and go one relaxing them for v-1 times (where v is the number of vertices) after which we will surely get the shortest path to all the edges even in case of negative edges.

We need to first make list of edges. In our case it would be (d,b), (c,d), (a,c), (a,b).

1). Take the list of all edges and mark the distances of all the vertices's as infinity, keep the first one ('a' in our case) as zero. Now we need to go and relax the vertices's for v-1 times (where v is number of vertices's), in our case it will be three. Lets start with d to b, d is infinity and b is infinity, so the shortest path from d to b would be infinity plus infinity which is infinity. Now we take c to d, again since both have infinity, so the shortest path at d would be infinity. Now take a to c, it would be 0+2, which is 2, we will change the shortest path at c from infinity to 2. Now we take a to b, and change the shortest path at b from infinity to 1. We have relaxed the vertices's for 1st time.

2). We repeat the process again, from d to b the shortest path would be infinity (value at d) minus 6 (since the edge has negative value), this will gives infinity. But the value at b is 1, which is less than infinity, so we are not going to change it. Now we take c to d, the shortest path would be 2+3 which is 5, shortest path at d was infinity, we will change it to 5. Now we take a to c, which gives shortest path as 2, which is already 2, so we are not going to change it. Same is the case from a to b. We have relaxed the vertices's for 2nd time.

3). Again we will go from d to b, the shortest path would be 5-6, thats -1. The shortest path at b is 1, which is greater than -1, so we will change it to -1. Then we will go from c to d, a to c, a to b, but the values remain unchanged.

4). We have relaxed vertices's for 3rd time. (v-1).

Bellman-Ford fails if there is a negative cycle in the graph. Like in the below case b-c-d has a cycle and total value is 1 + 3 + (-6), which is -3.

-K Himaanshu Shuklaa..

### #Algorithms Part 1: Graphs, BFS,DFS, Dijkstra Algorithm, Bellman-Ford Algorithm

__Graph Traversal__- Its the process of visiting and exploring a graph for processing.
- In this we visit and explore each vertex and edge in a graph such that all the vertices's are explored exactly once.
- Visiting a node means selecting a node, where as exploring means exploring the children nodes of the node which we have visited.

__Breadth First Search__- Its an algorithm for traversing trees and graphs.
- In BFS we start with the root node, explores all sibling nodes before moving on to the next level of siblings.
- Queue is the main data structure which is used while performing BFS.
- BFS is used as a crawlers in web-engines. It is the main algorithm which is used for indexing the web pages, it starts from the source page and follows all the links associated with that page. In this case each link is considered as a node in the graph.
- BFS is also used in GPS navigation to find the neighboring locations.
- BFS is also used in finding the shortest path

### Binary Search Trees, Balance Search Trees, 2-3 ST, Red- Black BST

__Tree Data Structure__- If we compare sorted arrays with linked list: Search is fast in SA (O(logn)) and slow in LL (O(n)), but insert & delete is slow in SA (O(n)) and fast in LL (O(1)).
- Binary search trees are very balanced in the sense that all these common operations like insert, delete, and search take about the same time (log n).
- In Binary search trees we have the nodes, which contain the data. Nodes are connected to other nodes through edges. The top node of the tree is called the root node (in a tree data structure, there can only be one root node).
- A node which has no children is called a leaf node.
- Any node may be considered to be the root of a subtree, which consists of its children and its children's children and so on. The level of a node tells us how far it is from the root.

### #Algorithms Part 4: Caching Algorithms in Java (LRU and LFU)

__What is Cache?__- As its expensive to every-time fetch data from the main storage, we story it in temporary location from where it can be retrieved faster. This temporary location is called Cache.
- A Cache is made of pool of entries and these entries are a copy of real data which are in storage and it is tagged with a tag (key identifier) value for retrieval.
- When an application receives a request to get a particular information, it is first checked in cache. If an entry is found with a tag matching with the request, it will be returned. Else it will be fetched from the main storage, kept in Cache and then returned to the client.

### Java Sorting Algorithms

__Selection Sort__- The selection sort algorithm sorts an array by repeatedly finding the minimum element (considering ascending order) from unsorted part and putting it at the beginning.
- The algorithm maintains two subarrays in a given array: (a).The subarray which is already sorted. (b). Remaining subarray which is unsorted.
- In every iteration of selection sort, the minimum element (considering ascending order) from the unsorted subarray is picked and moved to the sorted subarray.
- It is very simple to implement but it does not go well with large number of inputs.

### #LeetCode: Java Solution of Bitwise AND of Numbers Range problem

__Bitwise AND of Numbers Range__Given a range [m, n] where 0 <= m <= n <= 2147483647, return the bitwise AND of all numbers in this range, inclusive.

Example 1: Input: [5,7], Output: 4

Example 2:Input: [0,1], Output: 0

### Part 2.6: Leet Code Solutions For Java Coding Interview Round

__Valid Parenthesis String__Given a string containing only three types of characters: '(', ')' and '*', write a function to check whether this string is valid. We define the validity of a string by these rules:

- Any left parenthesis '(' must have a corresponding right parenthesis ')'.
- Any right parenthesis ')' must have a corresponding left parenthesis '('.
- Left parenthesis '(' must go before the corresponding right parenthesis ')'.
- '*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string.
- An empty string is also valid.

### Part 2.5: Leet Code Solutions For Java Coding Interview Round

__Perform String Shifts__You are given a string s containing lowercase English letters, and a matrix shift, where shift[i] = [direction, amount]:

direction can be 0 (for left shift) or 1 (for right shift).

amount is the amount by which string s is to be shifted.

A left shift by 1 means remove the first character of s and append it to the end.

Similarly, a right shift by 1 means remove the last character of s and add it to the beginning.

Return the final string after all operations.

**:**

__Example 1__Input: s = "abc", shift = [[0,1],[1,2]]

Output: "cab"

Explanation:

[0,1] means shift to left by 1. "abc" -> "bca"

[1,2] means shift to right by 2. "bca" -> "cab"

**:**

__Example 2__Input: s = "abcdefg", shift = [[1,1],[1,1],[0,2],[1,3]]

Output: "efgabcd"

Explanation:

[1,1] means shift to right by 1. "abcdefg" -> "gabcdef"

[1,1] means shift to right by 1. "gabcdef" -> "fgabcde"

[0,2] means shift to left by 2. "fgabcde" -> "abcdefg"

[1,3] means shift to right by 3. "abcdefg" -> "efgabcd"

**:**

__Constraints__1 <= s.length <= 100

s only contains lower case English letters.

1 <= shift.length <= 100

shift[i].length == 2

0 <= shift[i][0] <= 1

0 <= shift[i][1] <= 100

**GIT URL:**

__Java Solution of Leet Code's Perform String Shifts problem__

__Java Solution__

__Last Stone Weight__We have a collection of stones, each stone has a positive integer weight.

Each turn, we choose the two heaviest stones and smash them together.

Suppose the stones have weights x and y with x <= y. The result of this smash is:

If x == y, both stones are totally destroyed;

If x != y, the stone of weight x is totally destroyed, and the stone of weight y has new weight y-x.

At the end, there is at most 1 stone left. Return the weight of this stone (or 0 if there are no stones left.)

**Example 1**:

Input: [2,7,4,1,8,1]

Output: 1

**Explanation**:

We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then,

we combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,

we combine 2 and 1 to get 1 so the array converts to [1,1,1] then,

we combine 1 and 1 to get 0 so the array converts to [1] then that's the value of last stone.

**Note**:

1 <= stones.length <= 30

1 <= stones[i] <= 1000

**GIT URL:**

__Java Solution of Leet Code's Last Stone Weight problem__

__Java Solution__

__Product of Array Except Self__Given an array nums of n integers where n > 1, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].

**Example**:

Input: [1,2,3,4]

Output: [24,12,8,6]

Constraint: It's guaranteed that the product of the elements of any prefix or suffix of the array (including the whole array) fits in a 32 bit integer.

**Note**: Please solve it without division and in O(n).

**Algorithm**:

1). create a new array 'output' with the length same as the input array 'nums'. In 'output' array for a given index i, output[i] would contain the product of all the numbers to the left of i and product of all the numbers to the right of i.

2). We will first find the product of all the elements to the left. To do this let's assume in 'output' array for a given index i, output[i] would contain the product of all the numbers to the left of i.

3). For the element at index '0', there are no elements to the left, that's why output[0]= 1

4). output[i-1] will have the product of elements to the left of 'i-1', to do this we need to multiply nums[i - 1] with output[i-1]

5). Declare a int variable 'right', which cntains the product of all the elements to the right.

6). For the last element (the element at index 'length-1') there are no elements to the right, that's why R will be 1.

7). We need to update output[i] it will be the product of output[i] and 'right'. After doing this we need to update 'right' (it would be product of 'right' and nums[i]).

**GIT URL:**

__Java Solution of Leet Code's Product of Array Except Self problem__### Part 2.4: Leet Code Solutions For Java Coding Interview Round

__Length of Last Word__Given a string s consists of upper/lower-case alphabets and empty space characters ' ', return the length of last word (last word means the last appearing word if we loop from left to right) in the string.

### Part 2.3: Leet Code Solutions For Java Coding Interview Round

__Counting Elements__Given an integer array arr, count element x such that x + 1 is also in arr. If there're duplicates in arr, count them separately.

### Part 2.2: Leet Code Solutions For Java Coding Interview Round

__Single Number__Given a non-empty array of integers, every element appears twice except for one. Find that single one.

**: Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?**

__Note__

**Example 1**Input: [2,2,1]. Output: 1

**Example 2**Input: [4,1,2,1,2]. Output: 4

### Part 2.1: Leet Code Solutions For Java Coding Interview Round

__1). Remove K Digits__Given a non-negative integer number represented as a string, remove k digits from the number so that the new number is the smallest possible.

### Part 1: Java Algorithms For Coding Interview Round

__Two Sum__Given an array of integers, return indices of the two numbers such that they add up to a specific target. Let us assume that each input would have exactly one solution, and you may not use the same element twice. e.g: nums = [1,2,8,9], target = 9, it will return [0,8]

## November 23, 2019

## November 22, 2019

## November 21, 2019

## November 16, 2019

### #JNUFact: Is the fee hike in JNU justified?

__Total Number Of Students, Departments and courses offered in JNU__Let's first start with the number of students in JNU and number of departments , along with the courses offered. Here is how it looks:

Total number of students in JNU=8000.

Between the two categories, we have 72% of the campus covered:

- 4578 students (57%) are from social sciences, language, literature & arts.
- 1210 students (15%) are from International studies.

## November 14, 2019

### Preetisheel Singh basks in the 'shining' glory of Bala

Fresh from the super success of Housefull 4 and appreciation for her work for Ujda Chaman, ace makeup, hair and prosthetic character designer Preetisheel Singh is basking in the glory of critical acclaim for her latest film Bala... or should we say, for having constructed Ayushmann Khurrana's shining baldpate. Tch tch! ;-)

## November 12, 2019

## November 11, 2019

### #Cassandra Part 4

__Command To Create Keyspace__*CREATE KEYSPACE EmployeeDetails*

*WITH replication = {'class':'SimpleStrategy', 'replication_factor' : 3};*

To verify whether the table is created or not we can use the command Describe. If we use this command over keyspaces, it will display all the keyspaces created.

*DESCRIBE keyspaces;*

### #Cassandra Part 3

__Define commit log.__It is a mechanism that is used to recover data in case the database crashes. Every operation that is carried out is saved in the commit log. Using this the data can be recovered.

### #Cassandra Part 2 : Data Model, Keys, Ring Representation, Virtual Nodes

__Cassandra__- Cassandra is an open source, distributed database from Apache that is highly scalable and designed to manage very large amounts of structured data.
- Cassandra is made to easily deploy over a cluster of machines located at geographically different places.
- There is no master slave or central master server, so no single point of failure, no bottleneck, data is replicated, and a faulty node can be replaced without any downtime.
- Cassandra is linearly scalable, which means that with more nodes, the requests served per second per node will not go down. Also, the total throughput of the system will increase with each node being added.
- Cassandra is column oriented, much like a map (or better, a map of sorted maps) or a table with flexible columns where each column is essentially a key-value pair. So, we can add columns as we go, and each row can have a different set of columns (key-value).
- Cassandra does not provide any relational integrity. It is up to the application developer to perform relation management.
- It is a type of NoSQL database.
- Apache HBase and MongoDB are quite popular NoSQL databases besides Cassandra.
- It is widely used in Netflix, eBay, GitHub, Facebook, Twitter etc.
- Cassandra does automatic partitioning and replication.

__What is the main objective of creating Cassandra?__
The main objective of Cassandra is to handle a large amount of data. Furthermore, the objective also ensures fault tolerance with the swift transfer of data.

### #Cassandra Part 1: NoSQLDatabase

__NoSQLDatabase__- A NoSQL database is sometimes called as Not Only SQL. It is a database that provides a mechanism to store and retrieve data other than the tabular relations used in relational databases.
- These type databases are schema-free, support easy replication, have simple API, eventually consistent, and can handle huge amounts of data.
- Primary objective of a NoSQL database is to have: simplicity of design, horizontal scaling, and finer control over availability.
- SQL was designed to be a query language for relational databases, and relational databases are usually table- based, much like what we see in a spreadsheet. In a relational database, records are stored in rows and then the columns represent fields in each row. SQL allows us to query within and between tables in that relational database.
- On the other hand, NoSQL databases are more flexible, NoSQL databases allow us to define fields as we create a record.
- Nested values are common in NoSQL databases. We can have hashes and arrays and objects, and then nest more objects and arrays and hashes within those.
- Also fields are not standardized between records in NoSQL databases, we can have a different structure for every record in your NoSQL database.

## November 08, 2019

### देवउठनी एकादशी पर क्यों होता है तुलसी विवाह?

आज कार्तिक मास के शुक्ल पक्ष की एकादशी है। कहते है भगवान विष्णु अपनी चार महीने की निद्रा से आज उठते है इसीलिए इसे देवउठनी एकादशी या प्रबोधिनी एकादशी भी कहा जाता है ।

__भगवान विष्णु को जगाने का मंत्र__**भगवान् को निंद्रा से उठाने के लिए इस मन्त्र का जप करें, अगर उच्चारण न कर पाए तो 'उठो देवा, जागो देवा, बैठो देवा' कहकर श्रीनारायण को उठाएं।**

उत्तिष्ठ गोविन्द त्यज निद्रां जगत्पतये। त्वयि सुप्ते जगन्नाथ जगत् सुप्तं भवेदिदम्॥

उत्थिते चेष्टते सर्वमुत्तिष्ठोत्तिष्ठ माधव। गतामेघा वियच्चैव निर्मलं निर्मलादिशः॥

शारदानि च पुष्पाणि गृहाण मम केशव।

__तुलसी विवाह क्यों?__**प्रबोधिनी एकादशी के दिन तुलसी जी का विवाह भगवान शालिग्राम के साथ करवाने की भी परंपरा है।**