Given an array containing 0s, 1s and 2s, sort the array in place. You should treat numbers of the array as objects, hence, we can’t count 0s, 1s, and 2s to recreate the array.

The flag of the Netherlands consists of three colours: red, white and blue; and since our input array also consists of three different numbers that are why it is called Dutch National Flag problem.

Example 1:

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

Example 2:

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

So what is the plan?

So the idea is to solve, We can use a Two Pointers approach while iterating through the array. Let’s say the two pointers are called low and high which are pointing to the first and the last element of the array respectively. So while iterating, we will move all 0s before low and all 2s after high so that in the end, all 1s will be between low and high.

Let's code, shall we!

def dutch_flag(lst):
    lower_pointer = 0
    high_pointer = len(lst) - 1
    iteration_pointer = 0

    while iteration_pointer <= high_pointer:
        if lst[iteration_pointer] == 1:
            iteration_pointer += 1
        elif lst[iteration_pointer] == 0:
            lst[lower_pointer], lst[iteration_pointer] = lst[iteration_pointer], lst[lower_pointer]
            lower_pointer += 1
            iteration_pointer += 1
        elif lst[iteration_pointer] == 2:
            lst[high_pointer], lst[iteration_pointer] = lst[iteration_pointer], lst[high_pointer]
            high_pointer -= 1
    return lst


def main():
    arr = [1, 0, 2, 1, 0]
    dutch_flag(arr)
    print(arr)

    arr = [2, 2, 0, 1, 2, 0]
    dutch_flag(arr)
    print(arr)

The final out put is

[0, 0, 1, 1, 2] [0, 0, 1, 2, 2, 2]

Two

As a result, there is a good possibility that you will be evaluated on your implementations of graphs and trees, as well as other algorithms, during an interview. As a matter of fact, it is prudent for every developer to study and apply these data structures.

As part of that, I'll try to deconstruct one of the most popular interview questions about connected graphs in the business.

So let's get this party started.....

The question is as simple as it can get.

Given a boolean 2D matrix, find the number of islands. A group of connected 1s forms an island.

So that means you are given a matrix that is 2 dimensional. Which consist of 1's and 0's where "0" is water and "1" island. there are asking you to find the number of islands in the matrix.

Note: We have only considered the 4 sides of an element for a better understanding. Rather considering the diagonals sides as well.

Ok ! Now we have understood the problem. Let's see how to solve them.

So how would you solve this problem when you see this in your own interview.

PANIC 🥲 PANIC 🤷‍♂️

If you have no idea it's ok. All you need is to understand Connected Components in a Graph. Here is a geeksforgeeks LINK for you to have a quick look at it.

Now I assume you have a better understanding of Connected Components in a Graph. One can solve this by simply using the concept of connected components and DFS. So let's get into the code and I will explain along with the code for better understanding

def islandfinder(graph: list):
    no_of_islands = 0
    for i in range(len(graph)):
        for j in range(len(graph[i])):
            if graph[i][j] == 1:
                print(str(graph) + ' ' + str(no_of_islands))
                no_of_islands += 1

                dfs(i, j, graph)
    print(no_of_islands)

To begin with, I wrote a function that says island_finder

• what I intend to do is, to go to each element present in the 2D matrix and check if the element in the matrix[i][j] is "1" or "0"
• If the element in the matrix[i][j] is a "1" that is water I want to find all the connected elements of that element.
• To iterate through the matrix which is nothing but the list of lists in python. I have written two loops "i", "j"
• And then if the condition is met I will pass the element to a dfs to find the element.

So now we will see who I managed to write the dfs for this below.

def dfs(i, j, graph):
    n = len(graph[0])
    m = len(graph)
    if i < 0 or i >= m or j < 0 or j >= n or graph[i][j] != 1:
        return
    graph[i][j] = 2

    dfs(i, j + 1, graph)
    dfs(i, j - 1, graph)
    dfs(i + 1, j, graph)
    dfs(i - 1, j, graph)

So this function dfs above does nothing but find DFS. But with a little twist. 😁

-So once the element is passed to this function that is dfs, The dfs first checks for the edge cases where the edge elements of the graphs can throw an error.

• once we ignore the edge cases we mark the present element "2" we can mark with anything. This just not to resend the element to find_island function
• And use a recursive function and pass the 4 sides of the given element to the same dfs function to find the connected elements.

I have written the code with the inclusion of diagonal elements and with a different example below.

matrix = [
        [1, 0, 1, 0, 0, 0, 1, 1, 1, 1],
        [0, 0, 1, 0, 1, 0, 1, 0, 0, 0],
        [1, 1, 1, 1, 0, 0, 1, 0, 0, 0],
        [1, 0, 0, 1, 0, 1, 0, 0, 0, 0],
        [1, 1, 1, 1, 0, 0, 0, 1, 1, 1],
        [0, 1, 0, 1, 0, 0, 1, 1, 1, 1],
        [0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
        [0, 0, 0, 1, 0, 0, 1, 1, 1, 0],
        [1, 0, 1, 0, 1, 0, 0, 1, 0, 0],
        [1, 1, 1, 1, 0, 0, 0, 1, 1, 1]
    ]


def island_finder(graph: list):
    no_of_islands = 0
    for i in range(len(graph)):
        for j in range(len(graph[i])):
            if graph[i][j] == 1:
                print(str(graph) + ' ' + str(no_of_islands))
                no_of_islands += 1

                dfs(i, j, graph)
    print(no_of_islands)


def dfs(i, j, graph):
    n = len(graph[0])
    m = len(graph)
    if i < 0 or i >= m or j < 0 or j >= n or graph[i][j] != 1:
        return
    graph[i][j] = 2

    dfs(i, j + 1, graph)
    dfs(i, j - 1, graph)
    dfs(i + 1, j, graph)
    dfs(i - 1, j, graph)
    dfs(i - 1, j - 1, graph)
    dfs(i + 1, j + 1, graph)
    dfs(i + 1, j - 1, graph)
    dfs(i - 1, j + 1, graph)


island_finder(matrix)

That's it. Now pass the matrix to the find_island function and enjoy the result. 😁😎

Happy coding guys. see you next time with some more interesting problems. Till then NAMSTEY 👏👏🙌🙏

Now in this blog, I will try to put comprehensible steps of How to enable Multi-Factor Authentication (MFA) for S3 buckets? and at the same to time how to delete the MFA

So here are the prerequisites for MFA

• AWS account with root user access ( To activate MFA )
• AWS CLI installed on your local system
• MFA Device ( Oauth App or any MFA apps )

Now MFA in Amazon S3 can only be configured with AWS CLI and there is no other way around this. So let's get started...

1. First and very foremost let's head on to AWS and create an S3 bucket but remember MFA can only be activated for Versioned buckets. And also the bucket's name should be unique, So I have chosen mfatestbucket as the bucket name.

Now once you click on Create Bucket button you will be redirected to a new page just like displayed below

On this new page, you are required to give a name for your bucket. Remember that bucket's name should be unique. And chose your region. Since I am in India and ap-south-1 is the closest data center for me I have chosen this. But you are welcome to pick any of the AWS regions you want. And can also copy setting from existing buckets if you wish to.

Block Public Access setting - Remember it is always efficient to let your buckets be Private and available from the public. But sometimes S3 can be used to deploy static websites. In such cases, you are required to let your bucket be public.

Bucket Versioning - Amazon S3 versioning is a way of maintaining several item versions in the same bucket. The S3 versioning capabilities allow you to save, recover and restore each version of any item stored in your buckets. By versioning, both unexpected user activities and program faults may make it easier to recover. If Amazon S3 receives several requests for writing the same subject at a time, it saves all those objects once versioning is enabled for a bucket. And It is also required to Enable MFA in S3 Buckets

Additional options- There are some additional options like Tags, Encryptions, etc. But in this block, I am interested in concentrating only on enabling MFA from AWS CLI. But feel free to explore.

Now the bucket has been created with versioning we can check this by going to mfatestbucket properties. Here we can see that the properties and in these properties, we have Bucket Versioning. Which says the Bucket Versioning is enabled but the MFA is Disabled

And it is time to go to MFA enabling process. By going to the security credentials page as shown below.

And then you will reach Your Security Credentials page which is used to manage the credentials for your AWS account. In there you can see the MFA option just like displayed below and click on that to add the MFA with your Google Authentication app...

Now choose Virtual MFA for using MFA with Google Authentication app or any Authentication app.

And then open your Google Authentication app and scan the QR code.

And Enter the Two Consiquite Code that displays on your APP. Note the code reshuffles every one Minute. so enter two codes sequentially And then Click on Assign MFA

Now Your Account is set with your MFA App (Google Authentication app). So now we shall go to cmd and access AWS CLI. If not installed please click here here to do so.

Remember that the AWS profile Should be the root AWS user, not an IAM User

aws s3api list-buckets

{
    "Buckets": [

        {
            "Name": "mfatestbucket",
            "CreationDate": "2021-09-05T06:25:20+00:00"
        }

    ],
    "Owner": {
        "ID": "1ab1de8ca8eexxxxxxxxxxxxxxxxxxxxxxxxxxx"
    }
}

Now we can see the created bucket in here. Now let's see how to enable the MFA.

aws s3api put-bucket-versioning  
-- profile {root}  
-- bucket {my-bucket-name} 
-- versioning-configuration Status=Enabled,MFADelete=Enabled
-- mfa “{arn key} ”

This is the command structure. Remember '{' , '}' are not in the command they are just to let you see the variable parts.

• aws s3api put-bucket-versioning -- is the command to put versioning in s3

• Where { root } is the local root profile, Is your default profile is root you can ignore this.

• bucket {my-bucket-name} is your bucket name

• versioning-configuration Status=Enabled, MFADelete=Enabled - is to enable MFA

• mfa {arn key } -- arn can be found in the MFA setting in the profile and Key = your Google authentication app key (( Remember they must be separated by space ))

Copy the arn key -- In the MFA setting as shown below. and hold on to it.

Let's see How this command works in my case.

aws s3api put-bucket-versioning 
--profile root  
--bucket mfatestbucket 
--versioning-configuration Status=Enabled,MFADelete=Enabled 
--mfa "arn:aws:iam::xxxxxxxxx:mfa/root-account-mfa-device 817166 "

This is the command I have Used with my case. Bacasue

• I have a profile named root which is the root of my AWS.
• I have bucket Name mfatestbucket
• I want versioning-configuration Status=Enabled, MFADelete=Enabled
• I have copied my ARN As shown above, and pasted it here from the Security Credentials page
• My Oauth token from google App Is 817166

In the same manner, you can also disable the MFA with the same command but With MFADelete = Disable

aws s3api put-bucket-versioning 
--profile root  
--bucket mfatestbucket 
--versioning-configuration Status=Enabled,MFADelete=Disable 
--mfa "arn:aws:iam::xxxxxxxxx:mfa/root-account-mfa-device 817166 "

And Finally The MFA has been activated

🙌🙌👋🙋‍♂️ Happy Learning 🙌🙌👋🙋‍♂️

So what is git hub actions

You may construct custom lifecycle routines of software development straight into your Github repository via Github Actions. The workflows consist of several activities known as actions which may be carried out under specific circumstances automatically. This allows you to add continuous integration (CI), CD- and many more functions right in your repository. With that said let's get started.

Prerequisites

• AWS Account or IAM User
• Static Website
• Github Repo

Skip to Step - 2 if you already have a GitHub repo set.

Step - 1 Create A Github Repo

Step -2 Place The code in the repository

Now your repository is created, So let's start uploading your own Html, CSS, Js, Images, etc. in the repository. In case you want a dummy static website for a practice copy the code from below

spin.html

<!DOCTYPE html>
<html lang="en" >
<head>
  <meta charset="UTF-8">
  <title>Spin Wheel Using JS</title>
  <link rel="stylesheet" href="./spin.css">

</head>
<body>
<!-- partial:index.partial.html -->
<center><div id="chart"></div>
    <div id="question"><h1></h1></div></center>

    <script src="https://d3js.org/d3.v3.min.js" charset="utf-8"></script>
<!-- partial -->
  <script  src="./spin.js"></script>

</body>
</html>

spin.css

body{
    background-image: url(technical2.png);
}

text{
        font-family:Helvetica, Arial, sans-serif;
        font-size:11px;
        pointer-events:none;
    }
    #chart{
       /* position:absolute;

        width:500px;
        height:500px;
        top:0;
        left:0;*/
    }
    #question{
        position: absolute;
        width:400px;
        height:500px;
        top:180px;
        left:1000px;
    }
    #question h1{
        color: white;
        text-shadow: -1px 0px #fe0201, 1px 0px #06ffff, -2px 0px #fe0201, 2px 0px #06ffff, -3px 0px #fe0201, 3px 0px #06ffff, -4px 0px #fe0201, 4px 0px #06ffff, -5px 0px #fe0201, 5px 0px #06ffff;
        font-size: 90px;
        font-weight: bold;
        font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
        position: absolute;
        padding: 0;
        margin: 0;
        top:50%;
        -webkit-transform:translate(0,-50%);
                transform:translate(0,-50%);
    }

spin.js

var padding = {top:20, right:40, bottom:0, left:0},
            w = 500 - padding.left - padding.right,
            h = 500 - padding.top  - padding.bottom,
            r = Math.min(w, h)/2,
            rotation = 0,
            oldrotation = 0,
            picked = 100000,
            oldpick = [],
            color = d3.scale.category20();//category20c()
            //randomNumbers = getRandomNumbers();
        //http://osric.com/bingo-card-generator/?title=HTML+and+CSS+BINGO!&words=padding%2Cfont-family%2Ccolor%2Cfont-weight%2Cfont-size%2Cbackground-color%2Cnesting%2Cbottom%2Csans-serif%2Cperiod%2Cpound+sign%2C%EF%B9%A4body%EF%B9%A5%2C%EF%B9%A4ul%EF%B9%A5%2C%EF%B9%A4h1%EF%B9%A5%2Cmargin%2C%3C++%3E%2C{+}%2C%EF%B9%A4p%EF%B9%A5%2C%EF%B9%A4!DOCTYPE+html%EF%B9%A5%2C%EF%B9%A4head%EF%B9%A5%2Ccolon%2C%EF%B9%A4style%EF%B9%A5%2C.html%2CHTML%2CCSS%2CJavaScript%2Cborder&freespace=true&freespaceValue=Web+Design+Master&freespaceRandom=false&width=5&height=5&number=35#results
        var data = [
                    {"label":"",  "value":1,  "question":"Team 1"}, // padding
                    {"label":"",  "value":2,  "question":"Team 2"}, //font-family
                    {"label":"",  "value":3,  "question":"Team 3"}, //color
                    {"label":"",  "value":4,  "question":"Team 4"}, //font-weight
                    {"label":"",  "value":5,  "question":"Team 5"}, //font-size
                    {"label":"",  "value":6,  "question":"Team 6"}, //background-color
                    /*{"label":"IPAD PRO",  "value":7,  "question":"Which word is used for specifying an HTML tag that is inside another tag?"}, //nesting*/
                    /*{"label":"LAND",  "value":8,  "question":"Which side of the box is the third number in: margin:1px 1px 1px 1px; ?"}, //bottom
                    {"label":"MOTOROLLA",  "value":9,  "question":"What are the fonts that don't have serifs at the ends of letters called?"}, //sans-serif
                    {"label":"BMW", "value":10, "question":"With CSS selectors, what character prefix should one use to specify a class?"}*/
        ];
        var svg = d3.select('#chart')
            .append("svg")
            .data([data])
            .attr("width",  w + padding.left + padding.right)
            .attr("height", h + padding.top + padding.bottom);
        var container = svg.append("g")
            .attr("class", "chartholder")
            .attr("transform", "translate(" + (w/2 + padding.left) + "," + (h/2 + padding.top) + ")");
        var vis = container
            .append("g");

        var pie = d3.layout.pie().sort(null).value(function(d){return 1;});
        // declare an arc generator function
        var arc = d3.svg.arc().outerRadius(r);
        // select paths, use arc generator to draw
        var arcs = vis.selectAll("g.slice")
            .data(pie)
            .enter()
            .append("g")
            .attr("class", "slice");

        arcs.append("path")
            .attr("fill", function(d, i){ return color(i); })
            .attr("d", function (d) { return arc(d); });
        // add the text
        arcs.append("text").attr("transform", function(d){
                d.innerRadius = 0;
                d.outerRadius = r;
                d.angle = (d.startAngle + d.endAngle)/2;
                return "rotate(" + (d.angle * 180 / Math.PI - 90) + ")translate(" + (d.outerRadius -10) +")";
            })
            .attr("text-anchor", "end")
            .text( function(d, i) {
                return data[i].label;
            });
        container.on("click", spin);
        function spin(d){

            container.on("click", null);
            //all slices have been seen, all done
            console.log("OldPick: " + oldpick.length, "Data length: " + data.length);
            if(oldpick.length == data.length){
                console.log("done");
                container.on("click", null);
                return;
            }
            var  ps       = 360/data.length,
                 pieslice = Math.round(1440/data.length),
                 rng      = Math.floor((Math.random() * 1440) + 360);

            rotation = (Math.round(rng / ps) * ps);

            picked = Math.round(data.length - (rotation % 360)/ps);
            picked = picked >= data.length ? (picked % data.length) : picked;
            if(oldpick.indexOf(picked) !== -1){
                d3.select(this).call(spin);
                return;
            } else {
                oldpick.push(picked);
            }
            rotation += 90 - Math.round(ps/2);
            vis.transition()
                .duration(3000)
                .attrTween("transform", rotTween)
                .each("end", function(){
                    //mark question as seen
                    d3.select(".slice:nth-child(" + (picked + 1) + ") path")
                        .attr("fill", "#111");
                    //populate question
                    d3.select("#question h1")
                        .text(data[picked].question);
                    oldrotation = rotation;

                    /* Get the result value from object "data" */
                    console.log(data[picked].value)

                    /* Comment the below line for restrict spin to sngle time */
                    container.on("click", spin);
                });
        }
        //make arrow
        svg.append("g")
            .attr("transform", "translate(" + (w + padding.left + padding.right) + "," + ((h/2)+padding.top) + ")")
            .append("path")
            .attr("d", "M-" + (r*.15) + ",0L0," + (r*.05) + "L0,-" + (r*.05) + "Z")
            .style({"fill":"black"});
        //draw spin circle
        container.append("circle")
            .attr("cx", 0)
            .attr("cy", 0)
            .attr("r", 60)
            .style({"fill":"white","cursor":"pointer"});
        //spin text
        container.append("text")
            .attr("x", 0)
            .attr("y", 15)
            .attr("text-anchor", "middle")
            .text("SPIN")
            .style({"font-weight":"bold", "font-size":"30px"});


        function rotTween(to) {
          var i = d3.interpolate(oldrotation % 360, rotation);
          return function(t) {
            return "rotate(" + i(t) + ")";
          };
        }


        function getRandomNumbers(){
            var array = new Uint16Array(1000);
            var scale = d3.scale.linear().range([360, 1440]).domain([0, 100000]);
            if(window.hasOwnProperty("crypto") && typeof window.crypto.getRandomValues === "function"){
                window.crypto.getRandomValues(array);
                console.log("works");
            } else {
                //no support for crypto, get crappy random numbers
                for(var i=0; i < 1000; i++){
                    array[i] = Math.floor(Math.random() * 100000) + 1;
                }
            }
            return array;
        }

and place any image as a background 😊

This repository Looks like this

Step - 3 AWS time !

Log on to your AWS account and create IAM User with programmatic access and do as following -

And Now select the Security Credentials option

And then select download options

Once the ID and key are downloaded. hold on to them. and now create an S3 Bucket from the AWS console.

I have Named my bucket SPIN, but remember that when you are creating an S3 for your domain say example.com then the S3 name must be the name of your domain. Else the CNAM from your Domain will not work

And in permissions - Bucket policy add the following code

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PublicReadGetObject",
            "Effect": "Allow",
            "Principal": "*",
            "Action": [
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::Bucket-Name/*" ( Replace this with your bucket name ) 
            ]
        }
    ]
}

And then in properties of S3 Enable your Static web Hosting and give your page homepage name like Index.html

Now Get back to the GitHub repo create a File with the name .github in that folder make another folder Named workflows in that put the code below with file name

main.yml

name: Upload Website

on:
  push:
    branches:
      - main

jobs:
  iamvarshith_dev:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v1

      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
# aws-region
          aws-region: us-east-1( Replace with your AWS Bucket Region)

      - name: Deploy static site to S3 bucket
# Your bucker name
        run: aws s3 sync . s3://Bucket_name --delete

And Now find Secrets in the setting just like shown below.

And then add the AWS credentials which you have downloaded before from AWS.

Do the same with both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY remember that the names of these variables should not be changed.

Done ! Now push any update onto the main branch and go to GitHub actions to see if there is an error. Enjoy your automatic Push upgradable AWS S3 bucket with GitHub actions.

How to the length of the longest substring in it with no more than K distinct characters ?

The first and foremost step to solve the problem is to understand the question and figure what is given and what are we supposed to return as a result.

In this problem, we are given a string say str and an integer k . We are asked to return an integer say max_size which is the length of the longest sub string with less than the "k" number of distinct characters. Let's see the examples.

Example 1:

Input: String="araaci", K=2
Output: 4
Explanation: The longest substring with no more than '2' distinct characters is "araa".

Example 2:

Input: String="araaci", K=1
Output: 2
Explanation: The longest substring with no more than '1' distinct characters is "aa".

Example 3:

Input: String="cbbebi", K=3
Output: 5
Explanation: The longest substrings with no more than '3' distinct characters are "cbbeb" & "bbebi".

Example 4:

Input: String="cbbebi", K=10
Output: 6
Explanation: The longest substring with no more than '10' distinct characters is "cbbebi".

With this we have finally understood the question, So let's get started on thinking about how to solve the question

We can use a sliding window pattern

• We'll start by inserting characters from the beginning of the string until the HashMap has K distinct characters.
• Our sliding window will be formed by these characters. We're supposed to discover the window with the fewest number of unique characters. The length of this window will be remembered as the longest thus far.
• Following that, we'll incrementally add one character to the sliding window (i.e., slide the window forward).
• If the number of different characters in the HashMap is more than K, we'll try to reduce the window from the beginning of each phase. We'll reduce the size of the window until the HashMap contains no more than K unique characters.

Let's get to the code !

def Longest_Substring_with_K_Distinct_Characters(string, k):
    max_size = 0
    window_start = 0
    hashmap = {}
    for window_end in range(len(string)):
        right_char = string[window_end]
        if right_char not in hashmap:
            hashmap[right_char] = 0
        hashmap[right_char] += 1

        while len(hashmap) > k:
            hashmap[string[window_start]] -= 1
            if hashmap[string[window_start]] == 0:
                del hashmap[string[window_start]]

            window_start += 1
            max_size = max(max_size, window_end - window_start + 1)
    return max_size


string = "araaci"
k = 2

print(Longest_Substring_with_K_Distinct_Characters(string, k))

Happy coding 🙌🙌✌️👋👋

Any thoughts on how to solve this already ?

Great, for this problem we will use a Two-pointer type solution. Before that, we shall understand the question. Here we are given an array say arr which contains any integers. And asked to return an array of the squares of the elements in the arr in a sorted manner. Now I hope you understand the problem statement.

Example 1:

  Input: [-2, -1, 0, 2, 3]

  Output: [0, 1, 4, 4, 9]

Example 2:

Input: [-3, -1, 0, 1, 2]

Output: [0, 1, 1, 4, 9]

Now let's see how can we solve this problem ? This is an easy question to answer. The only difficulty is that we can have negative integers in the input array, which makes generating the output array with squares in sorted order a little more difficult.

Finding the index of the first non-negative number in the array might be a simpler technique. After that, we may iterate the array with Two Pointers. The non-negative numbers will be iterated with one pointer moving ahead, while the negative numbers will be iterated with the other pointer moving backward. At any point in the process, the number that results in a larger square will be added to the output array.

But there is one more solution, which is much better than the one mentioned above.

An alternative technique may be to apply two pointers beginning at each end of the input array, as the numbers at both ends can give us the biggest square. At any point in the process, we add the larger square to the result array and advance to the next/previous number indicated by the pointer.

• Create an array for the results and fill it with 0s initially
• Then create a variable say square_index for storing the last index of the result array and set it to length - 1 .
• Then take two pointers say right_pointer left_pointer and set length(array) -1 , 0 respectively
• Then check which of the left pointer square is greater or the right square. And then insert in the result array and increment the pointers when the condition is reached and also increment the square_index

Let's See the code in python3

def square_elemnts(arr):

    result_arr = [0 for i in range(len(arr))]
    left_pointer = 0
    square_index = len(arr) - 1
    right_pointer = len(arr) - 1
    while left_pointer <= right_pointer:
        squareleft = arr[left_pointer] * arr[left_pointer]
        squareright = arr[right_pointer] * arr[right_pointer]
        if squareleft > squareright:
            result_arr[square_index] = squareleft
            left_pointer += 1
        else:
            result_arr[square_index] = squareright
            right_pointer -= 1
        square_index -= 1
    return result_arr


print(square_elemnts([-2, -1, 0, 2, 3]))

result:[0, 1, 4, 9, 16]

This is similar to the last problem we solved on this blog on day one !. Try it on your own for some time before you look into the solution. Just think outside the box before writing the code. The perfect way to think of a solution is thinking , what would be an easy way for you to explain to a 5-Year-old how to do it. I think this is the trick for effortlessly writing a code for most of the problems .

So let's get started ... !

Problem 1: Given an unsorted array of numbers and a target ‘key’, remove all instances of ‘key’ in-place and return the new length of the array.

Test cases !

Example 1:

Input: [3, 2, 3, 6, 3, 10, 9, 3], Key=3
Output: 4
Explanation: The first four elements after removing every 'Key' will be [2, 6, 10, 9].

Example 2:

Input: [2, 11, 2, 2, 1], Key=2
Output: 2
Explanation: The first two elements after removing every 'Key' will be [11, 1].

So what do you think ! how should one solve this problem ?

As it is clear we are using two pointers to solve this. So for this case, the objective is to remove the key which is a duplicate element in the given array say arr. If you see in the first case the given key is 3. And at the 0th index, we have the 3 ! So in this case, we have to replace it with the next non-key element. that in this case, is '2'.

• So what we can do is take a pointer and point it to the 0th index value of an array. Say index_arr
• Now take another pointer that increments for every iteration. Say next
• Once we have these two pointers. We can make the next iterate and find the elements that are not equal to the KEY.
• And then replace the found element of index arr[next] with arr[index_arr]
• And then increment the index_arr by one
• And return the index_arr which is the new length of the substring !

So let's see the code !

def remove_duplicates_given(arr, key):
    key_element = 0

    for index in range(len(arr)):
        if arr[index] != key:
            arr[key_element] = arr[index]
            key_element += 1
    return key_element


print(remove_duplicates_given([3, 2, 3, 6, 3, 10, 9, 3], 3))
print(remove_duplicates_given([2, 11, 2, 2, 1], 2))

which give us the desired result

4
2

See you tomorrow with a new and interesting problem 😊😊🙌👍

Given an array of sorted numbers, remove all duplicates from it. You should not use any extra space; after removing the duplicates in place return the length of the subarray that has no duplicate in it.

Example 1:

Input: [2, 3, 3, 3, 6, 9, 9]
Output: 4
Explanation: The first four elements after removing the duplicates will be [2, 3, 6, 9].

Example 2:

Input: [2, 2, 2, 11]
Output: 2
Explanation: The first two elements after removing the duplicates will be [2, 11]

So how do we solve this ? Let's put our thinking caps on! ......

After thinking for a while, you might find a solution where you use a two-pointer and just count the repeated elements. Which gives you the answer.

def remove_duplicates(arr):
    duplicates = 0

    for pointer_start in range(1, len(arr)):
        pointer_end = pointer_start - 1
        if arr[pointer_start] == arr[pointer_end]:
            duplicates += 1
    return len(arr) - duplicates


print(remove_duplicates([2, 3, 3, 3, 6, 9, 9]))
print(remove_duplicates([2, 2, 2, 11]))

Output:

4
2

But We should not forget the given condition

You should remove all duplicates from the array ! Now one might ask that the arrays are immutable. I understand your confusion, Array size is immutable not the array itself. So we can manipulate the data once created not the size !.

So how should one solve this ?

This is a very good explanation I found online. What are we doing is we are taking two pointers

1. Next
2. nextNonDuplicate

We traverse two pointers just as shown in the image.

def remove_duplicates(arr):
  # index of the next non-duplicate element
  next_non_duplicate = 1

  i = 1
  while(i < len(arr)):
    if arr[next_non_duplicate - 1] != arr[i]:
      arr[next_non_duplicate] = arr[i]
      next_non_duplicate += 1
    i += 1
  return next_non_duplicate

In this journey, I would love to solve different kinds of problems by which I can learn and understand the Why and how to use different Data structures in different scenarios.

Why and What are Algorithms

For this question, if I put it bluntly. Computers are dumb ! Yes, they are ! They don't know What to do ? When to do it? How to do it ? anything. But all they know is to follow the instructions given to them. So since a machine is so dumb we have to write everything in a form of Binary for it to understand. So one might wonder that my python or java code is not is binary, how will my machine understand me ? To answer it simply, your java or any other language is called a high-level language. At the end of the compilation, it will be Binary. Compilers are not a topic of this blog so we shall discuss them in detail some other time.

Let's get back to the point. The systematic code you write for a machine to understand without any ambiguity can be called an Algorithm. YES, that means your "Hello World program is also an algorithm. But in this complex world of cloud computing, your print statements is very little.

Different types of algorithms

There are numerous algorithms out in the world. But there are a few which are fundamental for the rest

1. Recursive Algorithm
2. Divide and Conquer Algorithm
3. Dynamic Programming Algorithm
4. Brute Force Algorithm
5. Backtracking Algorithm
6. Greedy Algorithm

In this process of 100 Day, I will be discussing each one of the above Algorithms

And also in I would highly recommend you to join the 100-days Coding cult. I bet It will be great.

Benefits: What the #100DaysOfCode can do for you

There are several good reasons you should consider committing to this challenge:

Coding will become a daily habit for you — a habit that you can easily maintain after you’ve finished the challenge.

• Every day that you consistently code, you’ll build momentum. That momentum will make it easier for you to learn more advanced topics. You won’t have to spend extra time trying to remember what you did previously. You can stay in the “flow” of coding.

• You’ll make friends and meet like-minded people who are also working through this challenge alongside you. They’ll help you find the strength to keep coding even on the days when you don’t feel like you’re making progress. They can also help you when you inevitably get stuck.

• The projects that you’ll build will be small in scope, so by the time you finish, you’ll have completed several of them — and gained a wide range of experience.

• If you were just working through tutorials, you wouldn’t have much to show for it. But with #100DaysOfCode, you’ll build real portfolio projects that you can show to potential employers and share with your family.

• These projects will give you practice with concepts that frequently come up during developer job interviews.

• Your GitHub profile will look extremely active. And yes, hiring managers and recruiters do look at these.

• You’ll greatly diminish your fear of starting a new coding project. It will become a natural, ordinary thing to do.

• You’ll have a good reason to stop procrastinating and start coding every day.