Yash Chauhan's RSS Feed

Two Sum - Array 1 (Grind 75)

Mon, 20 Jun 2022 00:00:00 GMT

Approach 1 - Using for loops

We'll use a two pointer approach to solve this problem. We'll start by iterating through the array and keeping track of the sum of the current element and the target. If the sum is equal to the target, we'll return the indices of the two elements.

If we don't find the target, we'll move the pointer to the right.

vector<int> twoSum(vector<int>& nums, int target) {
    vector<int> ans;
    int n = nums.size();
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            if(nums[i] + nums[j] == target){
                ans.push_back(i);
                ans.push_back(j);
                return ans;
            }
          }
        }
    return ans;
}

The Big-O notation of this solution would be O(n^2) for time complexity and O(1) for space complexity, which indicates that it is not a very efficient solution for how fast it solves the problem.

Time Complexity: O(n^2) Space Complexity: O(1)

Approach 2 - Using a Hash Map

Here we'll use the map data structure to store the values of the array. The map will be keyed by the values of the array and the values will be the indices of the array.

Once we have the map, we can use the map to find the indices of the two numbers that add up to the target. We can do this by iterating through the map and checking if the target minus the current value of the map is in the map.

If we find the target minus the current value of the map in the map, we can return the indices of the two numbers. If we don't find the target minus the current value of the map in the map, we can add the current value of the map to the map.

vector<int> twoSum(vector<int>& nums, int target) {
    vector<int> ans;
    int n = nums.size();
    unordered_map<int, int> m;
    for(int i=0;i<n;i++){
        m[nums[i]] = i;
    }

    for(int i=0;i<n;i++){
        if(m.find(target - nums[i]) != m.end() && m[target - nums[i]] != i){
            ans.push_back(i);
            ans.push_back(m[target - nums[i]]);
            return ans;
        }
    }
    return ans;
}

Time Complexity: O(n) Space Complexity: O(n)

Link to the source code: Github

I hope this blog post helps you.

If you have any questions, please leave them in the comment section.

C++ STL Library

Thu, 16 Jun 2022 00:00:00 GMT

C++ STL Cheatsheet

STL is a C++ library that provides a set of useful functions and algorithms. It is a collection of templates that can be used to solve common problems. STL stands for Standard Template Library.

Algorithms - algorithms are functions that can be used to solve a specific problem.
Containers - It's a pre-built data-structure that can be used to store data.

Algorithms

Binary Search
Lower/Upper bound
min/max
reverse/rotate
sort/swap

etc..

feel free to add more

Containers - DocsLink

4 types of containers

Sequence Containers
Container Adaptors
Associative Containers
Unordered Associative

Sequence Containers

In C++, sequence containers are a group of template classes used to store data elements. They can be used to store any data elements, including custom classes.

There are five sequence containers offered by the C++ Standard Template Library.

They are:

Array
Vector
Dequeue
List

The container classes array, vector, and dequeue are implemented by using an array data structure.

1. Array - data stored in a continuos memory location of similar type

for ex, basic array
int basic[6] = {1,2,3,4,5,6};
STL implementation

array<int, 4> a = {1,2,3,4};
int size = a.size(); // to get the size
for (int i=0;i<size;i++){  //traversal
    cout << a[i] << endl;
}

cout << "Element at Index[2]: " << a.at(2) << endl;  // O(1)
cout <<"Empty or not-> " << a.empty() << endl; // return 0 or 1 O(1)

cout << "First Element: " << a.front() <<endl; // O(1)
cout << "Back Element: " << a.back() << endl;  // O(1)

2. Vector - Dynamic Array

Random access is possible for ex - a[i]

int vector<int> v;
cout <<"Capacity -> " v.capacity() <<endl;
cout <<"Size -> " v.size() <<endl;

v.push_back(1); //to insert element 
cout << "Element at Index[2]: " << v.at(2) << endl;  // O(1)

//print a vector
for (int i:v){
    cout << i << " ";
}

cout << "First Element: " << v.front() <<endl; // O(1)
cout << "Back Element: " << v.back() << endl;  // O(1)

//pop 
for(int i:v){
    cout << i << " ";
}
v.pop_back();

3. Dequeue -

Doubly Ended Queue -> operations can be perform from the beginning as well the emd. ex, insert, delete, etc..

Random access is possible for ex - a[i] It's Dynamic

deque<int> d;
d.push_back(1);
d.push_front(2);

//printing

for(int i:d){
    cout << i <<" ";
}

d.pop_back();
d.pop_front();

cout << "First Index Element -> " << d.front() << endl;
cout << "Back -> " << d.back() << endl;

cout << "Empty-> " << d.empty() <<endl;

cout <<"Size " << d.size() << endl;
d.erase(d.begin(), d.end());

4. List - (Doubly Linked List)

random access not possible, but it's dynamic

list<int> l;

l.push_back(1);
l.push_front(2);

for(int i:l){
    cout << l << endl;
}

l.erase(l.begin());

1. Stack - LIFO - Last In First Out

stack<string> s;

s.push("test1"); // push to the top
s.push("test2");
s.push("test3");

s.top(); // return the top element

s.pop(); // pop the top element

s.size(); // return the size

s.empty(); // return 0 or 1 (0-> empty, 1-> not empty)

2. Queue - FIFO - First In First Out

All operations complexity are O(1)

queue<string> q;

q.push("test1");
q.push("test2");
q.push("test3");

q.front(); // return the front element
q.pop(); // pop the front element

q.size(); // return the size

3. Priority Queue -

Priority Queue is a data structure that stores elements in a specific order. The order is determined by a user-defined comparison function.

maxheap is a priority queue (Default ) minheap is a priority queue

//maxheap

priority_queue<int> pq;

pq.push(1);
pq.push(2);
pq.push(3);

int n = pq.size(); // return the size
for (int i=0;i<n;i++){
    cout << pq.top() << endl;
}

output:
3 2 1

//minheap

priority_queue<int, vector<int>, greater<int>> pq;

pq.push(1);
pq.push(2);
pq.push(3);

int n = pq.size(); // return the size
for (int i=0;i<n;i++){
    cout << pq.top() << endl;
}

output:
1 2 3

4. Set -

Link to the source code: Gist

I hope this blog post will help you to get familiar with CPP stl.

If you have any questions, please leave them in the comment section.

How to get IP and Hostname in Golang

Thu, 16 Jun 2022 00:00:00 GMT

Program to get the IP address and hostname of the machine.

It returns only non-loopback addresses, e.g. 10.120.X.X.

package main

import (
	"log"
	"net"
	"os"
)

func main() {
	hostname, _ := os.Hostname() // get hostname
	addrs, err := net.LookupIP(hostname) // returns a slice of the IP addresses of the host 
	// lookupIP looks up host using the local resolver. It returns a slice of that host's IPv4 and IPv6 addresses.
	if err != nil {
		log.Println("Failed to detect machine host name. ", err.Error())
		return
	}
	log.Println("All Addrs: ", addrs)

	var ip string
	for _, addr := range addrs {
		if ipv4 := addr.To4(); ipv4 != nil {
			// only take the class B address
			if ipv4[0] == 172 {
				ip = ipv4.String()
				break
			}
		}
	}

	log.Println("Host name: ", hostname)
	log.Println("IP: ", ip)
}

output:

Link to the source code: Go PlayGround

I hope this blog post will help you to get familiar with getting the IP and Hostname.

If you have any questions, please leave them in the comment section.

C++ Maps STL

Thu, 16 Jun 2022 00:00:00 GMT

C++ Maps STL

Maps - are a data structure that can be used to store key-value pairs.

Inbuilt it uses Red-Black Tree to store the data

Types of maps include:

Maps
Unordered Maps
Multi-Maps

Map - is a data structure that can be used to store key-value pairs.

for example:

it would look something like this: (key, value)

1. Map

In Map the data is in sorted order based on the key. Internally this sorting is Happening using Red Black Tree Data Structure.

Key Points:

Sorted based on the key
Non-continuos memory
No duplicates
No random access
No fixed size

Time Operations: Insertion: O(log(n)) Search: O(log(n)) Deletion: O(log(n))

// Map
map<int, string> m;

// insert data 
m[1] = "abc";
m[2] = "def";
m[3] = "ghi";

m.insert(pair<int, string>(4, "jkl")); // insert data
m.insert({5, "mno"}); // insert data

map<int,string> :: iterator it; // iterator
for(it  = m.begin(); it != m.end(); ++it){ 
    cout << it->first << " " << it->second << endl; // or cout << (*it).first << (*it).second << endl;
}

// or 

for(auto &it : m){
    cout << it.first << " " << it.second << endl;
    //print the address of the element it points to
    // cout << &it << endl;
}

cout << m.size() << endl; // size of the map

// find the value of the key
auto it = m.find(1); // find the element with key 1
if(it == m.end()){
    cout << "Not found" << endl;
} else {
    cout << it->first << " " << it->second << endl;
}

// erase
m.erase(1); // erase the element with key 1

//clear the map
m.clear();

Let's see how to use the map in C++ using a problem.

Problem Statement 1: Given N numbers, find the number of pairs of numbers that add up to a given sum. (i.e. find the number of pairs of numbers that add up to a given sum)

Test Case & output: Inputs: 4 10 8 2 7 8 6 4 5 5

Output: 3

Program:

#include <iostream>
#include <map>
using namespace std;

int main(){
    int n, sum;
    cin >> n >> sum;
    map<int, int> m;
    for(int i = 0; i < n; i++){
        int x;
        cin >> x;
        m[x]++;
    }
    int count = 0;
    for(auto it = m.begin(); it != m.end(); ++it){
        int x = sum - it->first;
        if(m.find(x) != m.end()){
            count += m[x];
        }
    }
    cout << count << endl;
    return 0;
}

Problem Statement 2: Given N string, print unque strings in lexographic order with their frequency. (i.e. print unque strings in lexographic order with their frequency) n <= 10^5 |s| <= 100

Program:

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main(){
    map<string, int> m;
    int n;
    cin >> n;
    for(int i = 0; i < n; i++){
        string s;
        cin >> s;
        m[s]++;
    }

    // for(auto it = m.begin(); it != m.end(); ++it){
    //     cout << it->first << " " << it->second << endl;
    // }

    for(auto &it : m){
        cout << it.first << " " << it.second << endl;
    }

    return 0;
}

2. Unordered Map

All the function of the map are available in the unordered map. Inbuilt it uses Hash Table to store data

Time Complexity: Insertion: O(1) Search: O(1) Deletion: O(1)

Difference between map and unordered map:

Map is sorted based on the key <-> Unordered map is not sorted

Key Points:

No Sorting
Non-continuos memory
No duplicates
No random access

// Map
unordered_map<int, string> m;

// insert data 
m[1] = "abc";
m[2] = "def";
m[3] = "ghi";

m.insert(pair<int, string>(4, "jkl")); // insert data
m.insert({5, "mno"}); // insert data

unordered_map<int,string> :: iterator it; // iterator
for(it  = m.begin(); it != m.end(); ++it){ 
    cout << it->first << " " << it->second << endl; // or cout << (*it).first << (*it).second << endl;
}

// or 

for(auto &it : m){
    cout << it.first << " " << it.second << endl;
    //print the address of the element it points to
    // cout << &it << endl;
}

cout << m.size() << endl; // size of the map

// find the value of the key
auto it = m.find(1); // find the element with key 1
if(it == m.end()){
    cout << "Not found" << endl;
} else {
    cout << it->first << " " << it->second << endl;
}

// erase
m.erase(1); // erase the element with key 1

//clear the map
m.clear();

Let's see how to use the unordered_map in C++ using a problem.

Problem Statement 1: Given N string and Q queries. In each query you are given a string. Print the frequency of the that string.

Program:

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;

int main(){
    unordered_map<string, int> m;
    int n, q;
    cin >> n >> q;
    for(int i = 0; i < n; i++){
        string s;
        cin >> s;
        m[s]++;
    }

    for(int i = 0; i < q; i++){
        string s;
        cin >> s;
        cout << m[s] << endl;
    }
}

Input:
8
2
abc
def
abc
ghj
klm
mno
ghj
abc
abc
ghj

Output:
3
2

I hope this blog post will help you to get familiar with types of Maps in cpp and their Implementation.

If you have any questions, please leave them in the comment section.

Time package in Golang

Thu, 16 Jun 2022 00:00:00 GMT

Time package in Golang

In this blog post we'll see how to use the time package in Golang.

The package time feature allows us to measure and display time.

To use the time package in Golang, we need to import the package.

import "time"

For Seconds, Milliseconds, Nanoseconds, Microseconds, and Minutes, we can use the following functions:

For Current Time and Date:

// get current time in UTC timezone
currentTime := time.Now()

// To get the custom time in UTC timezone, we can use the following function:
t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC) // year, month, day, hour, minute, second, nanosecond, location
log.Println("Time: ", t)
log.Println("Time in UTC: ", t.UTC())
log.Println("Time in Local: ", t.Local())
log.Println("Time in Location: ", t.In(time.FixedZone("UTC", 0)))
log.Println("Get the time - weekday: ", t.Weekday())
log.Println("Get the time - year: ", t.Year())
log.Println("Get the time - month: ", t.Month())
log.Println("Get the time - day: ", t.Day())
log.Println("Get the time - hour: ", t.Hour())
log.Println("Get the time - minute: ", t.Minute())
log.Println("Get the time - second: ", t.Second())
log.Println("Get the time - nanosecond: ", t.Nanosecond())
log.Println("Get the time - location: ", t.Location())

output:

2022/06/17 17:09:42 Time:  2009-11-10 23:00:00 +0000 UTC
2022/06/17 17:09:42 Time in UTC:  2009-11-10 23:00:00 +0000 UTC     
2022/06/17 17:09:42 Time in Local:  2009-11-11 04:30:00 +0530 IST   
2022/06/17 17:09:42 Time in Location:  2009-11-10 23:00:00 +0000 UTC
2022/06/17 17:09:42 Get the time - weekday:  Tuesday
2022/06/17 17:09:42 Get the time - year:  2009
2022/06/17 17:09:42 Get the time - month:  November
2022/06/17 17:09:42 Get the time - day:  10
2022/06/17 17:09:42 Get the time - hour:  23
2022/06/17 17:09:42 Get the time - minute:  0
2022/06/17 17:09:42 Get the time - second:  0
2022/06/17 17:09:42 Get the time - nanosecond:  0
2022/06/17 17:09:42 Get the time - location:  UTC

For Seconds:

// get current time in seconds since Unix epoch (January 1, 1970 UTC)
secs := time.Now().Unix()

For Milliseconds:

// get current time in milliseconds since Unix epoch (January 1, 1970 UTC)
milliSecs := time.Now().UnixNano() / 1000000

// or 

// get current time in milliseconds since Unix epoch (January 1, 1970 UTC)
milli := time.Now().UnixMilli()

For Microseconds:

// get current time in microseconds since Unix epoch (January 1, 1970 UTC)
microSecs := time.Now().UnixNano() / 1000

For NanoSeconds:

// get current time in nanoseconds since Unix epoch (January 1, 1970 UTC)
nanoSecs := time.Now().UnixNano()

Get time in avaible formats:

// get current time in available formats
// get current time in RFC 3339 format
isoTime := time.Now().Format(time.RFC3339)
log.Println("ISO Time: ", isoTime)

// get current time in RFC 1123 format
rfcTime := time.Now().Format(time.RFC1123)
log.Println("RFC Time: ", rfcTime)

// print all the time formats in the local timezone
log.Println("Time in Local: ", time.Now().Format(time.Kitchen))
log.Println("Time in Local: ", time.Now().Format(time.Stamp))
log.Println("Time in Local: ", time.Now().Format(time.StampMilli))
log.Println("Time in Local: ", time.Now().Format(time.StampMicro))
log.Println("Time in Local: ", time.Now().Format(time.StampNano))
log.Println("Time in Local: ", time.Now().Format(time.RFC3339))
log.Println("Time in Local: ", time.Now().Format(time.RFC1123))

output:

2022/06/17 17:09:42 ISO Time:  2022-06-17T17:09:42+05:30
2022/06/17 17:09:42 RFC Time:  Fri, 17 Jun 2022 17:09:42 IST
2022/06/17 17:09:42 Time in Local:  5:09PM
2022/06/17 17:09:42 Time in Local:  Jun 17 17:09:42
2022/06/17 17:09:42 Time in Local:  Jun 17 17:09:42.984
2022/06/17 17:09:42 Time in Local:  Jun 17 17:09:42.985474
2022/06/17 17:09:42 Time in Local:  Jun 17 17:09:42.985474600
2022/06/17 17:09:42 Time in Local:  2022-06-17T17:09:42+05:30
2022/06/17 17:09:42 Time in Local:  Fri, 17 Jun 2022 17:09:42 IST

To format a time in a specific format, we can use the following function:

// format a time in string in the given layout
const layout = "Mon Jan 2 15:04:05 2006"
var stringDate string
t, _ := time.Parse(layout, stringDate)
date := t.Format("2006-01-02 15:04:05")
t, _ = time.Parse("2006-01-02 15:04:05", date)

Link to the source code: Gist

I hope this blog post will help you to get familiar with Time Package in Golang.

If you have any questions, please leave them in the comment section.