{
    "version": "https://jsonfeed.org/version/1",
    "title": "Schatz",
    "home_page_url": "https://swarag-n.github.io/Schatz/",
    "feed_url": "https://swarag-n.github.io/Schatz/feed.json",
    "description": "Journey to One Piece",
    "icon": "https://swarag-n.github.io/Schatz/apple-touch-icon.png",
    "favicon": "https://swarag-n.github.io/Schatz/favicon.ico",
    "expired": false,
    
    "author":  {
        "name": "Swarag Narayanasetty",
        "url": null,
        "avatar": null
    },
    
"items": [
    
        {
            "id": "https://swarag-n.github.io/Schatz/2022/11/16/find-pivot-index",
            "title": "Find Pivot Index",
            "summary": "nothing here",
            "content_text": "Problem StatementGiven an array of integers nums, calculate the pivot index of this array.The pivot index is the index where the sum of all the numbers strictly to the left of the index is equal to the sum of all the numbers strictly to the index’s right.If the index is on the left edge of the array, then the left sum is 0 because there are no elements to the left. This also applies to the right edge of the array.Return the leftmost pivot index. If no such index exists, return -1.Solutionclass Solution:    def pivotIndex(self, nums: List[int]) -&gt; int:         aa = 0        bb = sum(nums)                for i,j in enumerate(nums):            if aa == (bb-aa-j):                return i            aa += j        return -1",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given an array of integers nums, calculate the pivot index of this array.</p><p>The pivot index is the index where the sum of all the numbers strictly to the left of the index is equal to the sum of all the numbers strictly to the index’s right.</p><p>If the index is on the left edge of the array, then the left sum is 0 because there are no elements to the left. This also applies to the right edge of the array.</p><p>Return the leftmost pivot index. If no such index exists, return -1.</p><h2 id=\"solution\">Solution</h2><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"k\">class</span> <span class=\"nc\">Solution</span><span class=\"p\">:</span>    <span class=\"k\">def</span> <span class=\"nf\">pivotIndex</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">nums</span><span class=\"p\">:</span> <span class=\"n\">List</span><span class=\"p\">[</span><span class=\"nb\">int</span><span class=\"p\">])</span> <span class=\"o\">-&gt;</span> <span class=\"nb\">int</span><span class=\"p\">:</span>         <span class=\"n\">aa</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>        <span class=\"n\">bb</span> <span class=\"o\">=</span> <span class=\"nb\">sum</span><span class=\"p\">(</span><span class=\"n\">nums</span><span class=\"p\">)</span>                <span class=\"k\">for</span> <span class=\"n\">i</span><span class=\"p\">,</span><span class=\"n\">j</span> <span class=\"ow\">in</span> <span class=\"nb\">enumerate</span><span class=\"p\">(</span><span class=\"n\">nums</span><span class=\"p\">):</span>            <span class=\"k\">if</span> <span class=\"n\">aa</span> <span class=\"o\">==</span> <span class=\"p\">(</span><span class=\"n\">bb</span><span class=\"o\">-</span><span class=\"n\">aa</span><span class=\"o\">-</span><span class=\"n\">j</span><span class=\"p\">):</span>                <span class=\"k\">return</span> <span class=\"n\">i</span>            <span class=\"n\">aa</span> <span class=\"o\">+=</span> <span class=\"n\">j</span>        <span class=\"k\">return</span> <span class=\"o\">-</span><span class=\"mi\">1</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2022/11/16/find-pivot-index",
            
            
            
            "tags": ["leetcode","leetcode-75","python"],
            
            "date_published": "2022-11-16T00:00:00-06:00",
            "date_modified": "2022-11-16T00:00:00-06:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/10/16/count-distinct-elements-in-every-window",
            "title": "Count distinct elements in every window",
            "summary": "Given an array of integers and a number K. Find the count of distinct elements in every window of size K in the array.",
            "content_text": "Problem StatementGiven an array of integers and a number K. Find the count of distinct elements in every window of size K in the array.Edge Case  Check with window size 1 and NSolutionclass Solution{    ArrayList&lt;Integer&gt; countDistinct(int A[], int n, int k)    {        // code here         HashMap&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;();        int i=0;        for(;i&lt;k-1;i++){            map.put(A[i],map.getOrDefault(A[i],0)+1);        }                ArrayList&lt;Integer&gt;  res  = new ArrayList&lt;Integer&gt;();                for(;i&lt;n;i++){            map.put(A[i],map.getOrDefault(A[i],0)+1);                        res.add(map.size());                        map.put(A[i-k+1],map.get(A[i-k+1])-1);                        if(map.get(A[i-k+1])&lt;1){                map.remove(A[i-k+1]);            }        }        return res;    }}",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given an array of integers and a number K. Find the count of distinct elements in every window of size K in the array.</p><h3 id=\"edge-case\">Edge Case</h3><ul>  <li>Check with window size 1 and N</li></ul><h2 id=\"solution\">Solution</h2><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"nf\">countDistinct</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"no\">A</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">k</span><span class=\"o\">)</span>    <span class=\"o\">{</span>        <span class=\"c1\">// code here </span>        <span class=\"nc\">HashMap</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">,</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">map</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">HashMap</span><span class=\"o\">&lt;&gt;();</span>        <span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"k\">for</span><span class=\"o\">(;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">k</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"no\">A</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">],</span><span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">getOrDefault</span><span class=\"o\">(</span><span class=\"no\">A</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">],</span><span class=\"mi\">0</span><span class=\"o\">)+</span><span class=\"mi\">1</span><span class=\"o\">);</span>        <span class=\"o\">}</span>                <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span>  <span class=\"n\">res</span>  <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;();</span>                <span class=\"k\">for</span><span class=\"o\">(;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">n</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"no\">A</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">],</span><span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">getOrDefault</span><span class=\"o\">(</span><span class=\"no\">A</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">],</span><span class=\"mi\">0</span><span class=\"o\">)+</span><span class=\"mi\">1</span><span class=\"o\">);</span>                        <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">());</span>                        <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"no\">A</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">k</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">],</span><span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"no\">A</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">k</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">])-</span><span class=\"mi\">1</span><span class=\"o\">);</span>                        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"no\">A</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">k</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">])&lt;</span><span class=\"mi\">1</span><span class=\"o\">){</span>                <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">remove</span><span class=\"o\">(</span><span class=\"no\">A</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">k</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">]);</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>        <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/10/16/count-distinct-elements-in-every-window",
            
            
            
            "tags": ["gfg","potd","java","easy","edge_case"],
            
            "date_published": "2021-10-16T00:00:00-05:00",
            "date_modified": "2021-10-16T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/10/15/all-unique-permutations-of-an-array",
            "title": "All Unique Permutations of an array",
            "summary": "Given an array arr[] of length n. Find all possible unique permutations of the array.",
            "content_text": "Problem StatementGiven an array arr[] of length n. Find all possible unique permutations of the array.Solutionfrom itertools import permutationsclass Solution:    def uniquePerms(self, arr, n):        # code here         result = []        per = set(permutations(arr))        for i in per:            result.append(i)        return sorted(result)",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given an array arr[] of length n. Find all possible unique permutations of the array.</p><h2 id=\"solution\">Solution</h2><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">from</span> <span class=\"nn\">itertools</span> <span class=\"kn\">import</span> <span class=\"n\">permutations</span><span class=\"k\">class</span> <span class=\"nc\">Solution</span><span class=\"p\">:</span>    <span class=\"k\">def</span> <span class=\"nf\">uniquePerms</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">arr</span><span class=\"p\">,</span> <span class=\"n\">n</span><span class=\"p\">):</span>        <span class=\"c1\"># code here </span>        <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>        <span class=\"n\">per</span> <span class=\"o\">=</span> <span class=\"nb\">set</span><span class=\"p\">(</span><span class=\"n\">permutations</span><span class=\"p\">(</span><span class=\"n\">arr</span><span class=\"p\">))</span>        <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"n\">per</span><span class=\"p\">:</span>            <span class=\"n\">result</span><span class=\"p\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">)</span>        <span class=\"k\">return</span> <span class=\"nb\">sorted</span><span class=\"p\">(</span><span class=\"n\">result</span><span class=\"p\">)</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/10/15/all-unique-permutations-of-an-array",
            
            
            
            "tags": ["gfg","potd","python","medium"],
            
            "date_published": "2021-10-15T00:00:00-05:00",
            "date_modified": "2021-10-15T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/10/14/swap-all-odd-and-even-bits",
            "title": "Swap all odd and even bits",
            "summary": "The task is to swap all odd bits with even bits.",
            "content_text": "Problem StatementGiven an unsigned integer N. The task is to swap all odd bits with even bits. For example, if the given number is 23 (00010111), it should be converted to 43(00101011). Here, every even position bit is swapped with adjacent bit on the right side(even position bits are highlighted in the binary representation of 23), and every odd position bit is swapped with an adjacent on the left side.Appris  Refeesfhed about data    Edge Case    Check with numbers other greater than 109 like 231 and  232Notes  Refer Java Docs for Integer Parse Method  Refer Java Docs of String BuilderSolutionclass Solution{    //Function to swap odd and even bits.    public static int swapBits(int n)     {\t    // Your code\t    String s = Integer.toBinaryString(n);\t    StringBuilder sb = new StringBuilder(s);\t    if(s.length()%2==1 &amp;&amp; sb.length()&lt;31){\t        sb.insert(0,\"0\");\t    }\t    \t    for(int i=0;i&lt;s.length();i+=2){\t        char temp = sb.charAt(i);\t        sb.setCharAt(i,sb.charAt(i+1));\t        sb.setCharAt(i+1,temp);\t    }\t    String e = sb.toString();\t    \t    int res = Integer.parseInt(e, 2);\t    return res;\t}    }",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given an unsigned integer N. The task is to swap all odd bits with even bits. For example, if the given number is 23 (00010111), it should be converted to 43(00101011). Here, every even position bit is swapped with adjacent bit on the right side(even position bits are highlighted in the binary representation of 23), and every odd position bit is swapped with an adjacent on the left side.</p><h3 id=\"appris\">Appris</h3><ul>  <li>Refeesfhed about data    <h3 id=\"edge-case\">Edge Case</h3>  </li>  <li>Check with numbers other greater than <code>10<sup>9</sup></code> like <code>2<sup>31</sup></code> and  <code>2<sup>32</sup></code></li></ul><h3 id=\"notes\">Notes</h3><ul>  <li>Refer Java Docs for <a href=\"https://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html#parseInt(java.lang.String,%20int)\">Integer Parse Method</a></li>  <li>Refer Java Docs of <a href=\"https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html#setCharAt(int,%20char)\">String Builder</a></li></ul><h2 id=\"solution\">Solution</h2><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"c1\">//Function to swap odd and even bits.</span>    <span class=\"kd\">public</span> <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"nf\">swapBits</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">)</span>     <span class=\"o\">{</span>\t    <span class=\"c1\">// Your code</span>\t    <span class=\"nc\">String</span> <span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"nc\">Integer</span><span class=\"o\">.</span><span class=\"na\">toBinaryString</span><span class=\"o\">(</span><span class=\"n\">n</span><span class=\"o\">);</span>\t    <span class=\"nc\">StringBuilder</span> <span class=\"n\">sb</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">StringBuilder</span><span class=\"o\">(</span><span class=\"n\">s</span><span class=\"o\">);</span>\t    <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">()%</span><span class=\"mi\">2</span><span class=\"o\">==</span><span class=\"mi\">1</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">()&lt;</span><span class=\"mi\">31</span><span class=\"o\">){</span>\t        <span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">insert</span><span class=\"o\">(</span><span class=\"mi\">0</span><span class=\"o\">,</span><span class=\"s\">\"0\"</span><span class=\"o\">);</span>\t    <span class=\"o\">}</span>\t    \t    <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">();</span><span class=\"n\">i</span><span class=\"o\">+=</span><span class=\"mi\">2</span><span class=\"o\">){</span>\t        <span class=\"kt\">char</span> <span class=\"n\">temp</span> <span class=\"o\">=</span> <span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">charAt</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">);</span>\t        <span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">setCharAt</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">,</span><span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">charAt</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">));</span>\t        <span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">setCharAt</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">,</span><span class=\"n\">temp</span><span class=\"o\">);</span>\t    <span class=\"o\">}</span>\t    <span class=\"nc\">String</span> <span class=\"n\">e</span> <span class=\"o\">=</span> <span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">toString</span><span class=\"o\">();</span>\t    \t    <span class=\"kt\">int</span> <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"nc\">Integer</span><span class=\"o\">.</span><span class=\"na\">parseInt</span><span class=\"o\">(</span><span class=\"n\">e</span><span class=\"o\">,</span> <span class=\"mi\">2</span><span class=\"o\">);</span>\t    <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>\t<span class=\"o\">}</span>    <span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/10/14/swap-all-odd-and-even-bits",
            
            
            
            "tags": ["gfg","potd","java","easy","appris","edge_case","note"],
            
            "date_published": "2021-10-14T00:00:00-05:00",
            "date_modified": "2021-10-14T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/10/10/valid-pair-sum",
            "title": "Valid Pair Sum",
            "summary": "Given an array of size N, find the number of distinct pairs {i, j} (i != j) in the array such that the sum of a[i] and a[j] is greater than 0.",
            "content_text": "Problem StatementGiven an array of size N, find the number of distinct pairs {i, j} (i != j) in the array such that the sum of a[i] and a[j] is greater than 0.SolutionCode:class Solution:    def ValidPair(self, a, n):         # Sorting the given array         a = sorted(a)           # Variable to store the count of pairs         ans = 0          # Loop to iterate through the array         for i in range(n):               # Ignore if the value is negative             if (a[i] &lt;= 0):                 continue              # Finding the index using lower_bound             j = lower_bound(a,-a[i] + 1)               # Finding the number of pairs between             # two indices i and j             ans += i - j         return ans",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given an array of size N, find the number of distinct pairs {i, j} (i != j) in the array such that the sum of a[i] and a[j] is greater than 0.</p><h2 id=\"solution\">Solution</h2><p>Code:</p><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"k\">class</span> <span class=\"nc\">Solution</span><span class=\"p\">:</span>    <span class=\"k\">def</span> <span class=\"nf\">ValidPair</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">n</span><span class=\"p\">):</span>         <span class=\"c1\"># Sorting the given array </span>        <span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"nb\">sorted</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">)</span>           <span class=\"c1\"># Variable to store the count of pairs </span>        <span class=\"n\">ans</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>          <span class=\"c1\"># Loop to iterate through the array </span>        <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"p\">):</span>               <span class=\"c1\"># Ignore if the value is negative </span>            <span class=\"k\">if</span> <span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">&lt;=</span> <span class=\"mi\">0</span><span class=\"p\">):</span>                 <span class=\"k\">continue</span>              <span class=\"c1\"># Finding the index using lower_bound </span>            <span class=\"n\">j</span> <span class=\"o\">=</span> <span class=\"n\">lower_bound</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">,</span><span class=\"o\">-</span><span class=\"n\">a</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"p\">)</span>               <span class=\"c1\"># Finding the number of pairs between </span>            <span class=\"c1\"># two indices i and j </span>            <span class=\"n\">ans</span> <span class=\"o\">+=</span> <span class=\"n\">i</span> <span class=\"o\">-</span> <span class=\"n\">j</span>         <span class=\"k\">return</span> <span class=\"n\">ans</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/10/10/valid-pair-sum",
            
            
            
            "tags": ["gfg","potd","python"],
            
            "date_published": "2021-10-10T00:00:00-05:00",
            "date_modified": "2021-10-10T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/10/04/maximum-difference-of-zeros-and-ones-in-binary-string",
            "title": "Maximum difference of zeros and ones in binary string",
            "summary": "iven a binary string S consisting of 0s and 1s. The task is to find the maximum difference of the number of 0s and the number of 1s (number of 0s – number of 1s) in the substrings of a string.",
            "content_text": "Problem StatementGiven a binary string S consisting of 0s and 1s. The task is to find the maximum difference of the number of 0s and the number of 1s (number of 0s – number of 1s) in the substrings of a string.Note: In the case of all 1s, the answer will be -1.Appris  Application of Kadan AlgorithimEdge Case00000Solutionclass Solution {    int maxSubstring(String S) {        // code here        int val = 0;        int res = 0;        for(int i=0;i&lt;S.length();i++){            if(S.charAt(i)=='0'){                val++;            }else{                val--;            }            res = Math.max(val,res);            if(val&lt;0){                val=0;            }        }        if(val ==0 &amp;&amp; res ==0){            return -1;        }        return res;    }}",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given a binary string S consisting of 0s and 1s. The task is to find the maximum difference of the number of 0s and the number of 1s (number of 0s – number of 1s) in the substrings of a string.</p><p>Note: In the case of all 1s, the answer will be -1.</p><h3 id=\"appris\">Appris</h3><ul>  <li>Application of Kadan Algorithim</li></ul><h3 id=\"edge-case\">Edge Case</h3><div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>00000</code></pre></div></div><h2 id=\"solution\">Solution</h2><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span> <span class=\"o\">{</span>    <span class=\"kt\">int</span> <span class=\"nf\">maxSubstring</span><span class=\"o\">(</span><span class=\"nc\">String</span> <span class=\"no\">S</span><span class=\"o\">)</span> <span class=\"o\">{</span>        <span class=\"c1\">// code here</span>        <span class=\"kt\">int</span> <span class=\"n\">val</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"no\">S</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">();</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"no\">S</span><span class=\"o\">.</span><span class=\"na\">charAt</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">)==</span><span class=\"sc\">'0'</span><span class=\"o\">){</span>                <span class=\"n\">val</span><span class=\"o\">++;</span>            <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>                <span class=\"n\">val</span><span class=\"o\">--;</span>            <span class=\"o\">}</span>            <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"nc\">Math</span><span class=\"o\">.</span><span class=\"na\">max</span><span class=\"o\">(</span><span class=\"n\">val</span><span class=\"o\">,</span><span class=\"n\">res</span><span class=\"o\">);</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">val</span><span class=\"o\">&lt;</span><span class=\"mi\">0</span><span class=\"o\">){</span>                <span class=\"n\">val</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">val</span> <span class=\"o\">==</span><span class=\"mi\">0</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">res</span> <span class=\"o\">==</span><span class=\"mi\">0</span><span class=\"o\">){</span>            <span class=\"k\">return</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/10/04/maximum-difference-of-zeros-and-ones-in-binary-string",
            
            
            
            "tags": ["gfg","potd","java","medium","dp","appris","edge_case","note"],
            
            "date_published": "2021-10-04T00:00:00-05:00",
            "date_modified": "2021-10-04T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/10/03/check-for-bst",
            "title": "Check For Bst",
            "summary": null,
            "content_text": "Problem StatementGiven an undirected graph with V vertices and E edges, check whether it contains any cycle or not.Solutionclass Solution:        #Function to detect cycle in an undirected graph.    #def isCycle(self, V, adj):\t\tdef isCycle(self, V, adj):\t    #Code here\t\tvis = [0]*V\t\t\t\tdef dfs(cur, parent):\t\t    vis[cur] = 1\t\t    \t\t    for i in adj[cur]:\t\t        if not vis[i]:\t\t            if dfs(i, cur): return True\t\t        elif i != parent:\t\t            return True\t\t            \t\t    return False\t\t\t\tfor i in range(V):\t\t    if not vis[i]:\t\t        if dfs(i, -1): return True\t\t        \t\treturn False",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given an undirected graph with V vertices and E edges, check whether it contains any cycle or not.</p><h2 id=\"solution\">Solution</h2><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"k\">class</span> <span class=\"nc\">Solution</span><span class=\"p\">:</span>        <span class=\"c1\">#Function to detect cycle in an undirected graph.</span>    <span class=\"c1\">#def isCycle(self, V, adj):</span>\t\t<span class=\"k\">def</span> <span class=\"nf\">isCycle</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">V</span><span class=\"p\">,</span> <span class=\"n\">adj</span><span class=\"p\">):</span>\t    <span class=\"c1\">#Code here</span>\t\t<span class=\"n\">vis</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">*</span><span class=\"n\">V</span>\t\t\t\t<span class=\"k\">def</span> <span class=\"nf\">dfs</span><span class=\"p\">(</span><span class=\"n\">cur</span><span class=\"p\">,</span> <span class=\"n\">parent</span><span class=\"p\">):</span>\t\t    <span class=\"n\">vis</span><span class=\"p\">[</span><span class=\"n\">cur</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"mi\">1</span>\t\t    \t\t    <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"n\">adj</span><span class=\"p\">[</span><span class=\"n\">cur</span><span class=\"p\">]:</span>\t\t        <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"n\">vis</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]:</span>\t\t            <span class=\"k\">if</span> <span class=\"n\">dfs</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">,</span> <span class=\"n\">cur</span><span class=\"p\">):</span> <span class=\"k\">return</span> <span class=\"bp\">True</span>\t\t        <span class=\"k\">elif</span> <span class=\"n\">i</span> <span class=\"o\">!=</span> <span class=\"n\">parent</span><span class=\"p\">:</span>\t\t            <span class=\"k\">return</span> <span class=\"bp\">True</span>\t\t            \t\t    <span class=\"k\">return</span> <span class=\"bp\">False</span>\t\t\t\t<span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">V</span><span class=\"p\">):</span>\t\t    <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"n\">vis</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]:</span>\t\t        <span class=\"k\">if</span> <span class=\"n\">dfs</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">):</span> <span class=\"k\">return</span> <span class=\"bp\">True</span>\t\t        \t\t<span class=\"k\">return</span> <span class=\"bp\">False</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/10/03/check-for-bst",
            
            
            
            "tags": ["gfg","potd","python","medium"],
            
            "date_published": "2021-10-03T00:00:00-05:00",
            "date_modified": "2021-10-03T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/10/02/smallest-range-in-k-lists",
            "title": "Smallest range in K lists",
            "summary": "Given K sorted lists of integers, KSortedArray[] of size N each. The task is to find the smallest range that includes at least one element from each of the K lists. If more than one such range's are found, return the first such range found.",
            "content_text": "Problem StatementGiven K sorted lists of integers, KSortedArray[] of size N each. The task is to find the smallest range that includes at least one element from each of the K lists. If more than one such range’s are found, return the first such range found.Note  This a officail solution given by leetcode editorial    Solution    ```java  class Solution{    class Element implements Comparable {        int val;        int ind;        int row;        Element (int val, int ind, int row) {            this.val= val;            this.ind= ind;            this.row= row;        }        public int compareTo(Element e){            return this.val- e.val;        }    }\tint[] findSmallestRange(int[][] KSortedArray,int n,int k)\t{\t    int length=Integer.MAX_VALUE, low= Integer.MAX_VALUE, high= Integer.MIN_VALUE, max= Integer.MIN_VALUE;\t    PriorityQueue pq= new PriorityQueue&lt;&gt;();\t    for(int i=0; i&lt;k; i++){\t        max= Math.max(max, KSortedArray[i][0]);\t        pq.add(new Element(KSortedArray[i][0], 0, i));\t    }\t    length= max- pq.peek().val;\t    low= pq.peek().val;\t    high= max;\t   // System.out.println(length + \" \" + low + \" \" + high);\t    boolean flag= true;\t    while(flag){\t       // System.out.println(length + \" \" + low + \" \" + high);\t        Element x= pq.poll();\t        int row= x.row;\t        int ind= x.ind;\t        if(!(ind+1&lt;n)){\t            flag= false;\t            break;\t        } else {\t            Element ne= new Element(KSortedArray[row][ind+1], ind+1, row);\t            pq.add(ne);\t            max= Math.max(max, KSortedArray[row][ind+1]);\t            if(length&gt; max- pq.peek().val){\t                length= max- pq.peek().val;\t                low= pq.peek().val;\t                high= max;\t            }\t        }\t    }\t    int arr[]= {low, high};\t    return arr;\t}}```",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given K sorted lists of integers, KSortedArray[] of size N each. The task is to find the smallest range that includes at least one element from each of the K lists. If more than one such range’s are found, return the first such range found.</p><h3 id=\"note\">Note</h3><ul>  <li>This a officail solution given by leetcode editorial    <h2 id=\"solution\">Solution</h2>    <p>```java</p>  </li></ul><p>class Solution{    class Element implements Comparable<Element> {        int val;        int ind;        int row;        Element (int val, int ind, int row) {            this.val= val;            this.ind= ind;            this.row= row;        }        public int compareTo(Element e){            return this.val- e.val;        }    }\tint[] findSmallestRange(int[][] KSortedArray,int n,int k)\t{\t    int length=Integer.MAX_VALUE, low= Integer.MAX_VALUE, high= Integer.MIN_VALUE, max= Integer.MIN_VALUE;\t    PriorityQueue<Element> pq= new PriorityQueue&lt;&gt;();\t    for(int i=0; i&lt;k; i++){\t        max= Math.max(max, KSortedArray[i][0]);\t        pq.add(new Element(KSortedArray[i][0], 0, i));\t    }\t    length= max- pq.peek().val;\t    low= pq.peek().val;\t    high= max;\t   // System.out.println(length + \" \" + low + \" \" + high);\t    boolean flag= true;\t    while(flag){\t       // System.out.println(length + \" \" + low + \" \" + high);\t        Element x= pq.poll();\t        int row= x.row;\t        int ind= x.ind;\t        if(!(ind+1&lt;n)){\t            flag= false;\t            break;\t        } else {\t            Element ne= new Element(KSortedArray[row][ind+1], ind+1, row);\t            pq.add(ne);\t            max= Math.max(max, KSortedArray[row][ind+1]);\t            if(length&gt; max- pq.peek().val){\t                length= max- pq.peek().val;\t                low= pq.peek().val;\t                high= max;\t            }\t        }\t    }\t    int arr[]= {low, high};\t    return arr;\t}}```</Element></Element></p>",
            "url": "https://swarag-n.github.io/Schatz/2021/10/02/smallest-range-in-k-lists",
            
            
            
            "tags": ["gfg","potd","java","medium","hard"],
            
            "date_published": "2021-10-02T00:00:00-05:00",
            "date_modified": "2021-10-02T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/10/01/check-for-bst",
            "title": "Check for BST",
            "summary": "Given the root of a binary tree. Check whether it is a BST or not.",
            "content_text": "Problem StatementGiven the root of a binary tree. Check whether it is a BST or not.Note: We are considering that BSTs can not contain duplicate Nodes.A BST is defined as follows:  The left subtree of a node contains only nodes with keys less than the node’s key.  The right subtree of a node contains only nodes with keys greater than the node’s key.  Both the left and right subtrees must also be binary search trees.Appris  Inorder Traversal of Binary Search Tree results sorted array.Edge Case3 2 5 1 4Understanding Edge Case        4      /   \\    2       5      \\        6Note  This is the official solution provided by GeeksForGeeks EditorialSolution  Efficient Solutionpublic class Solution{    Node prev;    //Function to check whether a Binary Tree is BST or not.    boolean isBST(Node root)    {        // code here.        if (root != null)        {            if (!isBST(root.left))                return false;                        // allows only distinct values node            if (prev != null &amp;&amp; root.data &lt;= prev.data )                return false;            prev = root;            return isBST(root.right);        }        return true;    }}  🔴🔴🔴 Edge Case Failing Code    public class Solution{  Node prev; //Function to check whether a Binary Tree is BST or not. boolean isBST(Node root){     // code here.     if (root != null){         /* False if left is &gt; than node */         if (node.left != null &amp;&amp; node.left.data &gt; node.data)             return false;                     /* False if right is &lt; than node */         if (node.right != null &amp;&amp; node.right.data &lt; node.data)              return false;                      // allows only distinct values node         if (prev != null &amp;&amp; root.data &lt;= prev.data )             return false;                     prev = root;         return isBST(root.right);     }     return true; }}      ",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given the root of a binary tree. Check whether it is a BST or not.Note: We are considering that BSTs can not contain duplicate Nodes.A BST is defined as follows:</p><ul>  <li>The left subtree of a node contains only nodes with keys less than the node’s key.</li>  <li>The right subtree of a node contains only nodes with keys greater than the node’s key.</li>  <li>Both the left and right subtrees must also be binary search trees.</li></ul><h3 id=\"appris\">Appris</h3><ul>  <li>Inorder Traversal of Binary Search Tree results sorted array.</li></ul><h3 id=\"edge-case\">Edge Case</h3><div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>3 2 5 1 4</code></pre></div></div><p>Understanding Edge Case</p><div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>        4      /   \\    2       5      \\        6</code></pre></div></div><h3 id=\"note\">Note</h3><ul>  <li>This is the official solution provided by GeeksForGeeks Editorial</li></ul><h2 id=\"solution\">Solution</h2><ol>  <li>Efficient Solution</li></ol><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">public</span> <span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"nc\">Node</span> <span class=\"n\">prev</span><span class=\"o\">;</span>    <span class=\"c1\">//Function to check whether a Binary Tree is BST or not.</span>    <span class=\"kt\">boolean</span> <span class=\"nf\">isBST</span><span class=\"o\">(</span><span class=\"nc\">Node</span> <span class=\"n\">root</span><span class=\"o\">)</span>    <span class=\"o\">{</span>        <span class=\"c1\">// code here.</span>        <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">root</span> <span class=\"o\">!=</span> <span class=\"kc\">null</span><span class=\"o\">)</span>        <span class=\"o\">{</span>            <span class=\"k\">if</span> <span class=\"o\">(!</span><span class=\"n\">isBST</span><span class=\"o\">(</span><span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">left</span><span class=\"o\">))</span>                <span class=\"k\">return</span> <span class=\"kc\">false</span><span class=\"o\">;</span>                        <span class=\"c1\">// allows only distinct values node</span>            <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">prev</span> <span class=\"o\">!=</span> <span class=\"kc\">null</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">data</span> <span class=\"o\">&lt;=</span> <span class=\"n\">prev</span><span class=\"o\">.</span><span class=\"na\">data</span> <span class=\"o\">)</span>                <span class=\"k\">return</span> <span class=\"kc\">false</span><span class=\"o\">;</span>            <span class=\"n\">prev</span> <span class=\"o\">=</span> <span class=\"n\">root</span><span class=\"o\">;</span>            <span class=\"k\">return</span> <span class=\"nf\">isBST</span><span class=\"o\">(</span><span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">right</span><span class=\"o\">);</span>        <span class=\"o\">}</span>        <span class=\"k\">return</span> <span class=\"kc\">true</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div><ol>  <li>🔴🔴🔴 Edge Case Failing Code    <div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">public</span> <span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>  <span class=\"nc\">Node</span> <span class=\"n\">prev</span><span class=\"o\">;</span> <span class=\"c1\">//Function to check whether a Binary Tree is BST or not.</span> <span class=\"kt\">boolean</span> <span class=\"nf\">isBST</span><span class=\"o\">(</span><span class=\"nc\">Node</span> <span class=\"n\">root</span><span class=\"o\">){</span>     <span class=\"c1\">// code here.</span>     <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">root</span> <span class=\"o\">!=</span> <span class=\"kc\">null</span><span class=\"o\">){</span>         <span class=\"cm\">/* False if left is &gt; than node */</span>         <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">node</span><span class=\"o\">.</span><span class=\"na\">left</span> <span class=\"o\">!=</span> <span class=\"kc\">null</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"na\">left</span><span class=\"o\">.</span><span class=\"na\">data</span> <span class=\"o\">&gt;</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"na\">data</span><span class=\"o\">)</span>             <span class=\"k\">return</span> <span class=\"kc\">false</span><span class=\"o\">;</span>                     <span class=\"cm\">/* False if right is &lt; than node */</span>         <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">node</span><span class=\"o\">.</span><span class=\"na\">right</span> <span class=\"o\">!=</span> <span class=\"kc\">null</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"na\">right</span><span class=\"o\">.</span><span class=\"na\">data</span> <span class=\"o\">&lt;</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"na\">data</span><span class=\"o\">)</span>              <span class=\"k\">return</span> <span class=\"kc\">false</span><span class=\"o\">;</span>                      <span class=\"c1\">// allows only distinct values node</span>         <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">prev</span> <span class=\"o\">!=</span> <span class=\"kc\">null</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">data</span> <span class=\"o\">&lt;=</span> <span class=\"n\">prev</span><span class=\"o\">.</span><span class=\"na\">data</span> <span class=\"o\">)</span>             <span class=\"k\">return</span> <span class=\"kc\">false</span><span class=\"o\">;</span>                     <span class=\"n\">prev</span> <span class=\"o\">=</span> <span class=\"n\">root</span><span class=\"o\">;</span>         <span class=\"k\">return</span> <span class=\"nf\">isBST</span><span class=\"o\">(</span><span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">right</span><span class=\"o\">);</span>     <span class=\"o\">}</span>     <span class=\"k\">return</span> <span class=\"kc\">true</span><span class=\"o\">;</span> <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div>    </div>  </li></ol>",
            "url": "https://swarag-n.github.io/Schatz/2021/10/01/check-for-bst",
            
            
            
            "tags": ["gfg","potd","java","easy","appris","edge_case","note"],
            
            "date_published": "2021-10-01T00:00:00-05:00",
            "date_modified": "2021-10-01T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/30/vertical-traversal-of-binary-tree",
            "title": "Vertical Traversal of Binary Tree",
            "summary": "Given a Binary Tree, find the vertical traversal of it starting from the leftmost level to the rightmost level. If there are multiple nodes passing through a vertical line, then they should be printed as they appear in level order traversal of the tree.",
            "content_text": "Problem StatementGiven a Binary Tree, find the vertical traversal of it starting from the leftmost level to the rightmost level.If there are multiple nodes passing through a vertical line, then they should be printed as they appear in level order traversal of the tree.Note  Check for traversal type asked.Solution//User function Template for Javaclass MetaNode{    Node head;    int pos;    MetaNode(Node root,int position){        head = root;        pos = position;    }}class Solution{    //Function to find the vertical order traversal of Binary Tree.    static ArrayList &lt;Integer&gt; verticalOrder(Node root){        // add your code here        Map&lt;Integer, List &lt;Integer&gt;&gt;  res = new TreeMap&lt;&gt;();        ArrayDeque&lt;MetaNode&gt; q = new ArrayDeque&lt;&gt;();                MetaNode head = new MetaNode(root,0);        q.add(head);                while(q.isEmpty()!=true){            int cnt = q.size();            for(int i=0;i&lt;cnt;i++){                MetaNode cur = q.pop();                if (res.containsKey(cur.pos)!=true){                    res.put(cur.pos,new LinkedList &lt;Integer&gt;());                }                res.get(cur.pos).add(cur.head.data);                if(cur.head.left!=null){                    q.addLast(new MetaNode(cur.head.left,cur.pos-1));                }                if(cur.head.right!=null){                    q.addLast(new MetaNode(cur.head.right,cur.pos+1));                }            }        }                ArrayList&lt;Integer&gt; soln =  new ArrayList&lt;Integer&gt;();        for(List&lt;Integer&gt; temp:res.values()){            for(Integer val:temp){                soln.add(val);            }        }        return soln;    }}",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given a Binary Tree, find the vertical traversal of it starting from the leftmost level to the rightmost level.If there are multiple nodes passing through a vertical line, then they should be printed as they appear in level order traversal of the tree.</p><h3 id=\"note\">Note</h3><ul>  <li>Check for traversal type asked.</li></ul><h2 id=\"solution\">Solution</h2><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"c1\">//User function Template for Java</span><span class=\"kd\">class</span> <span class=\"nc\">MetaNode</span><span class=\"o\">{</span>    <span class=\"nc\">Node</span> <span class=\"n\">head</span><span class=\"o\">;</span>    <span class=\"kt\">int</span> <span class=\"n\">pos</span><span class=\"o\">;</span>    <span class=\"nc\">MetaNode</span><span class=\"o\">(</span><span class=\"nc\">Node</span> <span class=\"n\">root</span><span class=\"o\">,</span><span class=\"kt\">int</span> <span class=\"n\">position</span><span class=\"o\">){</span>        <span class=\"n\">head</span> <span class=\"o\">=</span> <span class=\"n\">root</span><span class=\"o\">;</span>        <span class=\"n\">pos</span> <span class=\"o\">=</span> <span class=\"n\">position</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"c1\">//Function to find the vertical order traversal of Binary Tree.</span>    <span class=\"kd\">static</span> <span class=\"nc\">ArrayList</span> <span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"nf\">verticalOrder</span><span class=\"o\">(</span><span class=\"nc\">Node</span> <span class=\"n\">root</span><span class=\"o\">){</span>        <span class=\"c1\">// add your code here</span>        <span class=\"nc\">Map</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">,</span> <span class=\"nc\">List</span> <span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;&gt;</span>  <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">TreeMap</span><span class=\"o\">&lt;&gt;();</span>        <span class=\"nc\">ArrayDeque</span><span class=\"o\">&lt;</span><span class=\"nc\">MetaNode</span><span class=\"o\">&gt;</span> <span class=\"n\">q</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayDeque</span><span class=\"o\">&lt;&gt;();</span>                <span class=\"nc\">MetaNode</span> <span class=\"n\">head</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">MetaNode</span><span class=\"o\">(</span><span class=\"n\">root</span><span class=\"o\">,</span><span class=\"mi\">0</span><span class=\"o\">);</span>        <span class=\"n\">q</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">head</span><span class=\"o\">);</span>                <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">q</span><span class=\"o\">.</span><span class=\"na\">isEmpty</span><span class=\"o\">()!=</span><span class=\"kc\">true</span><span class=\"o\">){</span>            <span class=\"kt\">int</span> <span class=\"n\">cnt</span> <span class=\"o\">=</span> <span class=\"n\">q</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">();</span>            <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">cnt</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>                <span class=\"nc\">MetaNode</span> <span class=\"n\">cur</span> <span class=\"o\">=</span> <span class=\"n\">q</span><span class=\"o\">.</span><span class=\"na\">pop</span><span class=\"o\">();</span>                <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">containsKey</span><span class=\"o\">(</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">pos</span><span class=\"o\">)!=</span><span class=\"kc\">true</span><span class=\"o\">){</span>                    <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">pos</span><span class=\"o\">,</span><span class=\"k\">new</span> <span class=\"nc\">LinkedList</span> <span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;());</span>                <span class=\"o\">}</span>                <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">pos</span><span class=\"o\">).</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">head</span><span class=\"o\">.</span><span class=\"na\">data</span><span class=\"o\">);</span>                <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">head</span><span class=\"o\">.</span><span class=\"na\">left</span><span class=\"o\">!=</span><span class=\"kc\">null</span><span class=\"o\">){</span>                    <span class=\"n\">q</span><span class=\"o\">.</span><span class=\"na\">addLast</span><span class=\"o\">(</span><span class=\"k\">new</span> <span class=\"nc\">MetaNode</span><span class=\"o\">(</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">head</span><span class=\"o\">.</span><span class=\"na\">left</span><span class=\"o\">,</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">pos</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">));</span>                <span class=\"o\">}</span>                <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">head</span><span class=\"o\">.</span><span class=\"na\">right</span><span class=\"o\">!=</span><span class=\"kc\">null</span><span class=\"o\">){</span>                    <span class=\"n\">q</span><span class=\"o\">.</span><span class=\"na\">addLast</span><span class=\"o\">(</span><span class=\"k\">new</span> <span class=\"nc\">MetaNode</span><span class=\"o\">(</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">head</span><span class=\"o\">.</span><span class=\"na\">right</span><span class=\"o\">,</span><span class=\"n\">cur</span><span class=\"o\">.</span><span class=\"na\">pos</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">));</span>                <span class=\"o\">}</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>                <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">soln</span> <span class=\"o\">=</span>  <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;();</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"nc\">List</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"nl\">temp:</span><span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">values</span><span class=\"o\">()){</span>            <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"nc\">Integer</span> <span class=\"nl\">val:</span><span class=\"n\">temp</span><span class=\"o\">){</span>                <span class=\"n\">soln</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">val</span><span class=\"o\">);</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>        <span class=\"k\">return</span> <span class=\"n\">soln</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/30/vertical-traversal-of-binary-tree",
            
            
            
            "tags": ["gfg","potd","java","medium","note"],
            
            "date_published": "2021-09-30T00:00:00-05:00",
            "date_modified": "2021-09-30T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/29/restricted-pacman",
            "title": "Restricted Pacman",
            "summary": "In the game of Restricted Pacman, an infinite linear path is given. Pacman has to start at position 0 and eat as many candies as possible. In one move he can only jump a distance of either M or N.  If M and N are coprime numbers, find how many candies will be left on the board after the game is over.",
            "content_text": "Problem StatementIn the game of Restricted Pacman, an infinite linear path is given. Pacman has to start at position 0 and eat as many candies as possible. In one move he can only jump a distance of either M or N.  If M and N are coprime numbers, find how many candies will be left on the board after the game is over.Note: The result is always finite as after a point X every index in the infinite path can be visited.Edge Case  Check with upper limits.  M and N are coprime, to check for prime factors before testing with code.Note  M and N are coprimes, so there is no chance of double counting a specific number.TriviaFind the largest index that can’t be obtained using any combination of M &amp; N using Frobenius Number which defines X = (M * N) – M – N.Solution  O(1) if you are familar with math behind Coin Problem    class Solution{ static int candies(int m, int n){     // Your code goes here     return ((m-1)*(n-1)/2); }}        O(n) Efficient Iterative DP Solution    class Solution{ static int candies(int m, int n){     // Your code goes here     int cnt=0;     int X = (n*m)-(n+m)+1;     boolean[] flags = new boolean[X];     flags[0]=true;     for(int i=1;i&lt;X;i++){         if(i-n &gt;= 0 &amp;&amp; flags[i-n]==true){             flags[i]=true;         }         if(i-m &gt;= 0 &amp;&amp; flags[i-m]==true){             flags[i]=true;         }         if(!flags[i]){             cnt++;         }     }     return cnt; }}        Brute Force Recusrive DP Solution    class Solution{ static int N,M; static int candies(int m, int n){     // Your code goes here     N = n;     M = m;     boolean[] flags = new boolean[n*m];     rectoggle(flags,0);             return cntflag(flags); }     static void rectoggle(boolean[] flags,int i){     if(i&lt;flags.length){         flags[i]=true;         rectoggle(flags,i+M);         rectoggle(flags,i+N);     }     return; }     static int cntflag(boolean[] flags){     int cnt = 0;     for(boolean flag:flags){         if(!flag){             cnt++;         }     }     return cnt; }}      ",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>In the game of Restricted Pacman, an infinite linear path is given. Pacman has to start at position 0 and eat as many candies as possible. In one move he can only jump a distance of either M or N.  If M and N are coprime numbers, find how many candies will be left on the board after the game is over.<br />Note: The result is always finite as after a point X every index in the infinite path can be visited.</p><h3 id=\"edge-case\">Edge Case</h3><ul>  <li>Check with upper limits.</li>  <li>M and N are coprime, to check for prime factors before testing with code.</li></ul><h3 id=\"note\">Note</h3><ul>  <li><code>M</code> and <code>N</code> are coprimes, so there is no chance of double counting a specific number.</li></ul><h3 id=\"trivia\">Trivia</h3><p>Find the largest index that can’t be obtained using any combination of M &amp; N using <a href=\"https://mathworld.wolfram.com/FrobeniusNumber.html\">Frobenius Number</a> which defines X = (M * N) – M – N.</p><h2 id=\"solution\">Solution</h2><ol>  <li><code>O(1)</code> if you are familar with math behind <a href=\"https://mathworld.wolfram.com/CoinProblem.html\">Coin Problem</a>    <div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span> <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"nf\">candies</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">m</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">){</span>     <span class=\"c1\">// Your code goes here</span>     <span class=\"k\">return</span> <span class=\"o\">((</span><span class=\"n\">m</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">)*(</span><span class=\"n\">n</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">)/</span><span class=\"mi\">2</span><span class=\"o\">);</span> <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div>    </div>  </li>  <li><code>O(n)</code> Efficient Iterative DP Solution    <div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span> <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"nf\">candies</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">m</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">){</span>     <span class=\"c1\">// Your code goes here</span>     <span class=\"kt\">int</span> <span class=\"n\">cnt</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span>     <span class=\"kt\">int</span> <span class=\"no\">X</span> <span class=\"o\">=</span> <span class=\"o\">(</span><span class=\"n\">n</span><span class=\"o\">*</span><span class=\"n\">m</span><span class=\"o\">)-(</span><span class=\"n\">n</span><span class=\"o\">+</span><span class=\"n\">m</span><span class=\"o\">)+</span><span class=\"mi\">1</span><span class=\"o\">;</span>     <span class=\"kt\">boolean</span><span class=\"o\">[]</span> <span class=\"n\">flags</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">boolean</span><span class=\"o\">[</span><span class=\"no\">X</span><span class=\"o\">];</span>     <span class=\"n\">flags</span><span class=\"o\">[</span><span class=\"mi\">0</span><span class=\"o\">]=</span><span class=\"kc\">true</span><span class=\"o\">;</span>     <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">1</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"no\">X</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>         <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">n</span> <span class=\"o\">&gt;=</span> <span class=\"mi\">0</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">flags</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">n</span><span class=\"o\">]==</span><span class=\"kc\">true</span><span class=\"o\">){</span>             <span class=\"n\">flags</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]=</span><span class=\"kc\">true</span><span class=\"o\">;</span>         <span class=\"o\">}</span>         <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">m</span> <span class=\"o\">&gt;=</span> <span class=\"mi\">0</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">flags</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">m</span><span class=\"o\">]==</span><span class=\"kc\">true</span><span class=\"o\">){</span>             <span class=\"n\">flags</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]=</span><span class=\"kc\">true</span><span class=\"o\">;</span>         <span class=\"o\">}</span>         <span class=\"k\">if</span><span class=\"o\">(!</span><span class=\"n\">flags</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]){</span>             <span class=\"n\">cnt</span><span class=\"o\">++;</span>         <span class=\"o\">}</span>     <span class=\"o\">}</span>     <span class=\"k\">return</span> <span class=\"n\">cnt</span><span class=\"o\">;</span> <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div>    </div>  </li>  <li>Brute Force Recusrive DP Solution    <div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span> <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"no\">N</span><span class=\"o\">,</span><span class=\"no\">M</span><span class=\"o\">;</span> <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"nf\">candies</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">m</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">){</span>     <span class=\"c1\">// Your code goes here</span>     <span class=\"no\">N</span> <span class=\"o\">=</span> <span class=\"n\">n</span><span class=\"o\">;</span>     <span class=\"no\">M</span> <span class=\"o\">=</span> <span class=\"n\">m</span><span class=\"o\">;</span>     <span class=\"kt\">boolean</span><span class=\"o\">[]</span> <span class=\"n\">flags</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">boolean</span><span class=\"o\">[</span><span class=\"n\">n</span><span class=\"o\">*</span><span class=\"n\">m</span><span class=\"o\">];</span>     <span class=\"n\">rectoggle</span><span class=\"o\">(</span><span class=\"n\">flags</span><span class=\"o\">,</span><span class=\"mi\">0</span><span class=\"o\">);</span>             <span class=\"k\">return</span> <span class=\"nf\">cntflag</span><span class=\"o\">(</span><span class=\"n\">flags</span><span class=\"o\">);</span> <span class=\"o\">}</span>     <span class=\"kd\">static</span> <span class=\"kt\">void</span> <span class=\"nf\">rectoggle</span><span class=\"o\">(</span><span class=\"kt\">boolean</span><span class=\"o\">[]</span> <span class=\"n\">flags</span><span class=\"o\">,</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">){</span>     <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">flags</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">){</span>         <span class=\"n\">flags</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]=</span><span class=\"kc\">true</span><span class=\"o\">;</span>         <span class=\"n\">rectoggle</span><span class=\"o\">(</span><span class=\"n\">flags</span><span class=\"o\">,</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"no\">M</span><span class=\"o\">);</span>         <span class=\"n\">rectoggle</span><span class=\"o\">(</span><span class=\"n\">flags</span><span class=\"o\">,</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"no\">N</span><span class=\"o\">);</span>     <span class=\"o\">}</span>     <span class=\"k\">return</span><span class=\"o\">;</span> <span class=\"o\">}</span>     <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"nf\">cntflag</span><span class=\"o\">(</span><span class=\"kt\">boolean</span><span class=\"o\">[]</span> <span class=\"n\">flags</span><span class=\"o\">){</span>     <span class=\"kt\">int</span> <span class=\"n\">cnt</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>     <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">boolean</span> <span class=\"nl\">flag:</span><span class=\"n\">flags</span><span class=\"o\">){</span>         <span class=\"k\">if</span><span class=\"o\">(!</span><span class=\"n\">flag</span><span class=\"o\">){</span>             <span class=\"n\">cnt</span><span class=\"o\">++;</span>         <span class=\"o\">}</span>     <span class=\"o\">}</span>     <span class=\"k\">return</span> <span class=\"n\">cnt</span><span class=\"o\">;</span> <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div>    </div>  </li></ol>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/29/restricted-pacman",
            
            
            
            "tags": ["gfg","potd","java","medium","appris","edge_case"],
            
            "date_published": "2021-09-29T00:00:00-05:00",
            "date_modified": "2021-09-29T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/28/sort-a-stack",
            "title": "Sort a stack",
            "summary": "Given a stack, the task is to sort it such that the top of the stack has the greatest element.",
            "content_text": "Problem StatementGiven a stack, the task is to sort it such that the top of the stack has the greatest element.Solutionclass GfG{\tpublic Stack&lt;Integer&gt; sort(Stack&lt;Integer&gt; s){\t\t//add code here.\t\tif (s.isEmpty() != true){\t\t    Integer temp = s.pop();\t\t    s = sort(s);\t\t    sortInsert(s,temp);\t\t}\t\treturn s;\t}\t\tpublic void sortInsert(Stack&lt;Integer&gt; s, Integer val){\t    if(s.isEmpty() == true || s.peek() &lt;= val){\t        s.push(val);\t    }else{\t        Integer temp = s.pop();\t        sortInsert(s,val);\t        s.push(temp);\t    }\t}}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given a stack, the task is to sort it such that the top of the stack has the greatest element.</p><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">GfG</span><span class=\"o\">{</span>\t<span class=\"kd\">public</span> <span class=\"nc\">Stack</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"nf\">sort</span><span class=\"o\">(</span><span class=\"nc\">Stack</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">s</span><span class=\"o\">){</span>\t\t<span class=\"c1\">//add code here.</span>\t\t<span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">isEmpty</span><span class=\"o\">()</span> <span class=\"o\">!=</span> <span class=\"kc\">true</span><span class=\"o\">){</span>\t\t    <span class=\"nc\">Integer</span> <span class=\"n\">temp</span> <span class=\"o\">=</span> <span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">pop</span><span class=\"o\">();</span>\t\t    <span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"n\">sort</span><span class=\"o\">(</span><span class=\"n\">s</span><span class=\"o\">);</span>\t\t    <span class=\"n\">sortInsert</span><span class=\"o\">(</span><span class=\"n\">s</span><span class=\"o\">,</span><span class=\"n\">temp</span><span class=\"o\">);</span>\t\t<span class=\"o\">}</span>\t\t<span class=\"k\">return</span> <span class=\"n\">s</span><span class=\"o\">;</span>\t<span class=\"o\">}</span>\t\t<span class=\"kd\">public</span> <span class=\"kt\">void</span> <span class=\"nf\">sortInsert</span><span class=\"o\">(</span><span class=\"nc\">Stack</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">s</span><span class=\"o\">,</span> <span class=\"nc\">Integer</span> <span class=\"n\">val</span><span class=\"o\">){</span>\t    <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">isEmpty</span><span class=\"o\">()</span> <span class=\"o\">==</span> <span class=\"kc\">true</span> <span class=\"o\">||</span> <span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">peek</span><span class=\"o\">()</span> <span class=\"o\">&lt;=</span> <span class=\"n\">val</span><span class=\"o\">){</span>\t        <span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">push</span><span class=\"o\">(</span><span class=\"n\">val</span><span class=\"o\">);</span>\t    <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>\t        <span class=\"nc\">Integer</span> <span class=\"n\">temp</span> <span class=\"o\">=</span> <span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">pop</span><span class=\"o\">();</span>\t        <span class=\"n\">sortInsert</span><span class=\"o\">(</span><span class=\"n\">s</span><span class=\"o\">,</span><span class=\"n\">val</span><span class=\"o\">);</span>\t        <span class=\"n\">s</span><span class=\"o\">.</span><span class=\"na\">push</span><span class=\"o\">(</span><span class=\"n\">temp</span><span class=\"o\">);</span>\t    <span class=\"o\">}</span>\t<span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/28/sort-a-stack",
            
            
            
            "tags": ["gfg","potd","java","easy"],
            
            "date_published": "2021-09-28T00:00:00-05:00",
            "date_modified": "2021-09-28T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/27/the-preparations",
            "title": "The Preparations",
            "summary": "Chef has an exam which will start exactly M minutes from now. However, instead of preparing for his exam, Chef started watching Season-1 of Superchef. Season-1 has N episodes, and the duration of each episode is K minutes.",
            "content_text": "Problem StatementChef has an exam which will start exactly M minutes from now. However, instead of preparing for his exam, Chef started watching Season-1 of Superchef. Season-1 has N episodes, and the duration of each episode is K minutes.Will Chef be able to finish watching Season-1 strictly before the exam starts?Solution# cook your dish hereT = int(input())for _ in range(T):    M,N,K = list(map(int,input().split(\" \")))        if M&gt;(N*K):        print(\"YES\")    else:        print(\"NO\")",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Chef has an exam which will start exactly M minutes from now. However, instead of preparing for his exam, Chef started watching Season-1 of Superchef. Season-1 has N episodes, and the duration of each episode is K minutes.</p><p>Will Chef be able to finish watching Season-1 strictly before the exam starts?</p><h3 id=\"solution\">Solution</h3><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"c1\"># cook your dish here</span><span class=\"n\">T</span> <span class=\"o\">=</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"nb\">input</span><span class=\"p\">())</span><span class=\"k\">for</span> <span class=\"n\">_</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">T</span><span class=\"p\">):</span>    <span class=\"n\">M</span><span class=\"p\">,</span><span class=\"n\">N</span><span class=\"p\">,</span><span class=\"n\">K</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">map</span><span class=\"p\">(</span><span class=\"nb\">int</span><span class=\"p\">,</span><span class=\"nb\">input</span><span class=\"p\">().</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s\">\" \"</span><span class=\"p\">)))</span>        <span class=\"k\">if</span> <span class=\"n\">M</span><span class=\"o\">&gt;</span><span class=\"p\">(</span><span class=\"n\">N</span><span class=\"o\">*</span><span class=\"n\">K</span><span class=\"p\">):</span>        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s\">\"YES\"</span><span class=\"p\">)</span>    <span class=\"k\">else</span><span class=\"p\">:</span>        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s\">\"NO\"</span><span class=\"p\">)</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/27/the-preparations",
            
            
            
            "tags": ["codechef","START13C","python","easy"],
            
            "date_published": "2021-09-27T00:00:00-05:00",
            "date_modified": "2021-09-27T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/27/maximum-light-up",
            "title": "Maximum Light Up",
            "summary": "Chef has allocated himself a budget of P rupees to buy Diwali crackers. There are only 3 types of crackers available in the market and each type of cracker can be bought any number of times.",
            "content_text": "Problem StatementChef has allocated himself a budget of P rupees to buy Diwali crackers. There are only 3 types of crackers available in the market and each type of cracker can be bought any number of times.Fuljhari, where each costs a rupeesAnar, where each costs b rupeesChakri, where each costs c rupeesThe crackers have the following interesting properties:-A Fuljhari can be lit on its ownTo light an Anar, you will need x FuljharisTo light a Chakri, you will need y FuljharisWhat’s the maximum total of Anars and Chakris that Chef can light up with his given budget.Solution# cook your dish hereT = int(input())for _ in range(T):    P,a,b,c,x,y = list(map(int,input().split(\" \")))    b = b+a*x;    c = c+a*y;        cnt = 0    if(P//b &gt; P//c):        cnt+= P//b        rem = P - (P//b * b)        cnt += rem//c    else:        cnt+= P//c        rem = P - (P//c * c)        cnt += rem//b        print(cnt)",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Chef has allocated himself a budget of P rupees to buy Diwali crackers. There are only 3 types of crackers available in the market and each type of cracker can be bought any number of times.</p><p>Fuljhari, where each costs a rupeesAnar, where each costs b rupeesChakri, where each costs c rupeesThe crackers have the following interesting properties:-</p><p>A Fuljhari can be lit on its ownTo light an Anar, you will need x FuljharisTo light a Chakri, you will need y FuljharisWhat’s the maximum total of Anars and Chakris that Chef can light up with his given budget.</p><h3 id=\"solution\">Solution</h3><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"c1\"># cook your dish here</span><span class=\"n\">T</span> <span class=\"o\">=</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"nb\">input</span><span class=\"p\">())</span><span class=\"k\">for</span> <span class=\"n\">_</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">T</span><span class=\"p\">):</span>    <span class=\"n\">P</span><span class=\"p\">,</span><span class=\"n\">a</span><span class=\"p\">,</span><span class=\"n\">b</span><span class=\"p\">,</span><span class=\"n\">c</span><span class=\"p\">,</span><span class=\"n\">x</span><span class=\"p\">,</span><span class=\"n\">y</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">map</span><span class=\"p\">(</span><span class=\"nb\">int</span><span class=\"p\">,</span><span class=\"nb\">input</span><span class=\"p\">().</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s\">\" \"</span><span class=\"p\">)))</span>    <span class=\"n\">b</span> <span class=\"o\">=</span> <span class=\"n\">b</span><span class=\"o\">+</span><span class=\"n\">a</span><span class=\"o\">*</span><span class=\"n\">x</span><span class=\"p\">;</span>    <span class=\"n\">c</span> <span class=\"o\">=</span> <span class=\"n\">c</span><span class=\"o\">+</span><span class=\"n\">a</span><span class=\"o\">*</span><span class=\"n\">y</span><span class=\"p\">;</span>        <span class=\"n\">cnt</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>    <span class=\"k\">if</span><span class=\"p\">(</span><span class=\"n\">P</span><span class=\"o\">//</span><span class=\"n\">b</span> <span class=\"o\">&gt;</span> <span class=\"n\">P</span><span class=\"o\">//</span><span class=\"n\">c</span><span class=\"p\">):</span>        <span class=\"n\">cnt</span><span class=\"o\">+=</span> <span class=\"n\">P</span><span class=\"o\">//</span><span class=\"n\">b</span>        <span class=\"n\">rem</span> <span class=\"o\">=</span> <span class=\"n\">P</span> <span class=\"o\">-</span> <span class=\"p\">(</span><span class=\"n\">P</span><span class=\"o\">//</span><span class=\"n\">b</span> <span class=\"o\">*</span> <span class=\"n\">b</span><span class=\"p\">)</span>        <span class=\"n\">cnt</span> <span class=\"o\">+=</span> <span class=\"n\">rem</span><span class=\"o\">//</span><span class=\"n\">c</span>    <span class=\"k\">else</span><span class=\"p\">:</span>        <span class=\"n\">cnt</span><span class=\"o\">+=</span> <span class=\"n\">P</span><span class=\"o\">//</span><span class=\"n\">c</span>        <span class=\"n\">rem</span> <span class=\"o\">=</span> <span class=\"n\">P</span> <span class=\"o\">-</span> <span class=\"p\">(</span><span class=\"n\">P</span><span class=\"o\">//</span><span class=\"n\">c</span> <span class=\"o\">*</span> <span class=\"n\">c</span><span class=\"p\">)</span>        <span class=\"n\">cnt</span> <span class=\"o\">+=</span> <span class=\"n\">rem</span><span class=\"o\">//</span><span class=\"n\">b</span>        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cnt</span><span class=\"p\">)</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/27/maximum-light-up",
            
            
            
            "tags": ["codechef","START13C","python","easy"],
            
            "date_published": "2021-09-27T00:00:00-05:00",
            "date_modified": "2021-09-27T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/27/magical-doors",
            "title": "Magical Doors",
            "summary": "Chef wants to cross a hallway of N doors. These N doors are represented as a string. Each door is initially either open or close, represented by 1 or 0 respectively. Chef is required to go through all the doors one by one in the order that they appear, starting from the leftmost door and moving only rightwards at each step.",
            "content_text": "Problem StatementChef wants to cross a hallway of N doors. These N doors are represented as a string. Each door is initially either open or close, represented by 1 or 0 respectively. Chef is required to go through all the doors one by one in the order that they appear, starting from the leftmost door and moving only rightwards at each step.To make the journey easier, Chef has a magic wand, using which Chef can flip the status of all the doors at once. Determine the minimum number of times Chef has to use this wand to cross the hallway of doors.For example, the doors are 10011. Chef will start from the left and enter the first door. After passing through that door, the magic wand is waved. This flips the string to 01100. Now Chef passes through the next two doors in one go. Again, just before reaching the 4th door, the magic wand is waved. Now that the string is in its original state, Chef passes through the last two doors as well. The minimum number of times the magic wand needed to be used here was 2.Solution# cook your dish hereT = int(input())for _ in range(T):    S = input()    cnt = 0        if(S[0]==\"1\"):        i = 1;        while(i&lt;len(S)):            while(i&lt;len(S) and S[i]==S[i-1]):                i+=1;            if(i&lt;len(S)):                cnt+=1                i+=1;    else:        cnt+=1        i = 1;        while(i&lt;len(S)):            while(i&lt;len(S) and S[i]==S[i-1]):                i+=1;            if(i&lt;len(S)):                cnt+=1                i+=1;    print(cnt)",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Chef wants to cross a hallway of N doors. These N doors are represented as a string. Each door is initially either open or close, represented by 1 or 0 respectively. Chef is required to go through all the doors one by one in the order that they appear, starting from the leftmost door and moving only rightwards at each step.</p><p>To make the journey easier, Chef has a magic wand, using which Chef can flip the status of all the doors at once. Determine the minimum number of times Chef has to use this wand to cross the hallway of doors.</p><p>For example, the doors are 10011. Chef will start from the left and enter the first door. After passing through that door, the magic wand is waved. This flips the string to 01100. Now Chef passes through the next two doors in one go. Again, just before reaching the 4th door, the magic wand is waved. Now that the string is in its original state, Chef passes through the last two doors as well. The minimum number of times the magic wand needed to be used here was 2.</p><h3 id=\"solution\">Solution</h3><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"c1\"># cook your dish here</span><span class=\"n\">T</span> <span class=\"o\">=</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"nb\">input</span><span class=\"p\">())</span><span class=\"k\">for</span> <span class=\"n\">_</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">T</span><span class=\"p\">):</span>    <span class=\"n\">S</span> <span class=\"o\">=</span> <span class=\"nb\">input</span><span class=\"p\">()</span>    <span class=\"n\">cnt</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>        <span class=\"k\">if</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">==</span><span class=\"s\">\"1\"</span><span class=\"p\">):</span>        <span class=\"n\">i</span> <span class=\"o\">=</span> <span class=\"mi\">1</span><span class=\"p\">;</span>        <span class=\"k\">while</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)):</span>            <span class=\"k\">while</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)</span> <span class=\"ow\">and</span> <span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span><span class=\"o\">==</span><span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]):</span>                <span class=\"n\">i</span><span class=\"o\">+=</span><span class=\"mi\">1</span><span class=\"p\">;</span>            <span class=\"k\">if</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)):</span>                <span class=\"n\">cnt</span><span class=\"o\">+=</span><span class=\"mi\">1</span>                <span class=\"n\">i</span><span class=\"o\">+=</span><span class=\"mi\">1</span><span class=\"p\">;</span>    <span class=\"k\">else</span><span class=\"p\">:</span>        <span class=\"n\">cnt</span><span class=\"o\">+=</span><span class=\"mi\">1</span>        <span class=\"n\">i</span> <span class=\"o\">=</span> <span class=\"mi\">1</span><span class=\"p\">;</span>        <span class=\"k\">while</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)):</span>            <span class=\"k\">while</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)</span> <span class=\"ow\">and</span> <span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span><span class=\"o\">==</span><span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]):</span>                <span class=\"n\">i</span><span class=\"o\">+=</span><span class=\"mi\">1</span><span class=\"p\">;</span>            <span class=\"k\">if</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)):</span>                <span class=\"n\">cnt</span><span class=\"o\">+=</span><span class=\"mi\">1</span>                <span class=\"n\">i</span><span class=\"o\">+=</span><span class=\"mi\">1</span><span class=\"p\">;</span>    <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cnt</span><span class=\"p\">)</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/27/magical-doors",
            
            
            
            "tags": ["codechef","START13C","python","easy"],
            
            "date_published": "2021-09-27T00:00:00-05:00",
            "date_modified": "2021-09-27T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/27/finding-middle-element-in-a-linked-list",
            "title": "Finding middle element in a linked list",
            "summary": "The task is to complete the function getMiddle() which takes a head reference as the only argument and should return the data at the middle node of the linked list.",
            "content_text": "Problem StatementGiven a singly linked list of N nodes.The task is to find the middle of the linked list. For example, if the linked list is1-&gt; 2-&gt;3-&gt;4-&gt;5, then the middle node of the list is 3.If there are two middle nodes(in case, when N is even), print the second middle element.For example, if the linked list given is 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;6, then the middle node of the list is 4.Edge Case  Check with Single ElementSolution/* Node of a linked list class Node {   int data;    Node next;    Node(int d)  { data = d;  next = null; }}*/class Solution{    int getMiddle(Node head){         // Your code here.        if (head == null ){            return 0;        }        if(head.next ==null){            return head.data;        }        Node fast = head;        Node slow = head;        while(fast!=null &amp;&amp; fast.next!=null){            fast = fast.next.next;            slow = slow.next;        }        return slow.data;    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given a singly linked list of N nodes.The task is to find the middle of the linked list. For example, if the linked list is1-&gt; 2-&gt;3-&gt;4-&gt;5, then the middle node of the list is 3.If there are two middle nodes(in case, when N is even), print the second middle element.For example, if the linked list given is 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;6, then the middle node of the list is 4.</p><h2 id=\"edge-case\">Edge Case</h2><ul>  <li>Check with Single Element</li></ul><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"cm\">/* Node of a linked list class Node {   int data;    Node next;    Node(int d)  { data = d;  next = null; }}*/</span><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"kt\">int</span> <span class=\"nf\">getMiddle</span><span class=\"o\">(</span><span class=\"nc\">Node</span> <span class=\"n\">head</span><span class=\"o\">){</span>         <span class=\"c1\">// Your code here.</span>        <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">head</span> <span class=\"o\">==</span> <span class=\"kc\">null</span> <span class=\"o\">){</span>            <span class=\"k\">return</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">head</span><span class=\"o\">.</span><span class=\"na\">next</span> <span class=\"o\">==</span><span class=\"kc\">null</span><span class=\"o\">){</span>            <span class=\"k\">return</span> <span class=\"n\">head</span><span class=\"o\">.</span><span class=\"na\">data</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"nc\">Node</span> <span class=\"n\">fast</span> <span class=\"o\">=</span> <span class=\"n\">head</span><span class=\"o\">;</span>        <span class=\"nc\">Node</span> <span class=\"n\">slow</span> <span class=\"o\">=</span> <span class=\"n\">head</span><span class=\"o\">;</span>        <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">fast</span><span class=\"o\">!=</span><span class=\"kc\">null</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">fast</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">!=</span><span class=\"kc\">null</span><span class=\"o\">){</span>            <span class=\"n\">fast</span> <span class=\"o\">=</span> <span class=\"n\">fast</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">;</span>            <span class=\"n\">slow</span> <span class=\"o\">=</span> <span class=\"n\">slow</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"k\">return</span> <span class=\"n\">slow</span><span class=\"o\">.</span><span class=\"na\">data</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/27/finding-middle-element-in-a-linked-list",
            
            
            
            "tags": ["gfg","potd","java","easy","edge_case"],
            
            "date_published": "2021-09-27T00:00:00-05:00",
            "date_modified": "2021-09-27T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/27/chef-in-vaccination-queue",
            "title": "Chef in Vaccination Queue",
            "summary": null,
            "content_text": "Problem StatementThere are N people in the vaccination queue, Chef is standing on the Pth position from the front of the queue. It takes X minutes to vaccinate a child and Y minutes to vaccinate an elderly person. Assume Chef is an elderly person.You are given a binary array A1,A2,…,AN of length N, where Ai=1 denotes there is an elderly person standing on the ith position of the queue, Ai=0 denotes there is a child standing on the ith position of the queue. You are also given the three integers P,X,Y. Find the number of minutes after which Chef’s vaccination will be completed.Solution# cook your dish here2T = int(input())for _ in range(T):    N,P,X,Y = list(map(int,input().split(\" \")))    A = input().split(\" \")    val = 0    for i in range(0,P):        if(A[i]==\"0\"):           val+=X        else:            val+=Y    print(val)",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>There are N people in the vaccination queue, Chef is standing on the Pth position from the front of the queue. It takes X minutes to vaccinate a child and Y minutes to vaccinate an elderly person. Assume Chef is an elderly person.</p><p>You are given a binary array A1,A2,…,AN of length N, where Ai=1 denotes there is an elderly person standing on the ith position of the queue, Ai=0 denotes there is a child standing on the ith position of the queue. You are also given the three integers P,X,Y. Find the number of minutes after which Chef’s vaccination will be completed.</p><h3 id=\"solution\">Solution</h3><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"c1\"># cook your dish here2</span><span class=\"n\">T</span> <span class=\"o\">=</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"nb\">input</span><span class=\"p\">())</span><span class=\"k\">for</span> <span class=\"n\">_</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">T</span><span class=\"p\">):</span>    <span class=\"n\">N</span><span class=\"p\">,</span><span class=\"n\">P</span><span class=\"p\">,</span><span class=\"n\">X</span><span class=\"p\">,</span><span class=\"n\">Y</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">map</span><span class=\"p\">(</span><span class=\"nb\">int</span><span class=\"p\">,</span><span class=\"nb\">input</span><span class=\"p\">().</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s\">\" \"</span><span class=\"p\">)))</span>    <span class=\"n\">A</span> <span class=\"o\">=</span> <span class=\"nb\">input</span><span class=\"p\">().</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s\">\" \"</span><span class=\"p\">)</span>    <span class=\"n\">val</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>    <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span><span class=\"n\">P</span><span class=\"p\">):</span>        <span class=\"k\">if</span><span class=\"p\">(</span><span class=\"n\">A</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span><span class=\"o\">==</span><span class=\"s\">\"0\"</span><span class=\"p\">):</span>           <span class=\"n\">val</span><span class=\"o\">+=</span><span class=\"n\">X</span>        <span class=\"k\">else</span><span class=\"p\">:</span>            <span class=\"n\">val</span><span class=\"o\">+=</span><span class=\"n\">Y</span>    <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">val</span><span class=\"p\">)</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/27/chef-in-vaccination-queue",
            
            
            
            "tags": ["codechef","START13C","python","easy"],
            
            "date_published": "2021-09-27T00:00:00-05:00",
            "date_modified": "2021-09-27T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/26/count-occurences-of-anagrams",
            "title": "Count Occurences of Anagrams",
            "summary": "Given a word pat and a text txt. Return the count of the occurences of anagrams of the word in the text.",
            "content_text": "Problem StatementGiven a word pat and a text txt. Return the count of the occurences of anagrams of the word in the text.Note  Check for substrings not subsequence or subset. Read HereSolutionclass Solution {    int search(String pat, String txt) {        // code here        if(pat.length()&gt;txt.length()){            return 0;        }        int a = (int)'a';        int idx = 0;        int pl = pat.length();        int tl = txt.length();                int[] pat_cnt = new int[26];        int[] txt_cnt = new int[26];                for(;idx&lt;pl;idx++){            pat_cnt[((int)pat.charAt(idx))-a]++;            txt_cnt[((int)txt.charAt(idx))-a]++;        }                int res = 0;        if(Arrays.equals(pat_cnt,txt_cnt)){            res++;        }                for(;idx&lt;tl;idx++){            txt_cnt[((int)txt.charAt(idx-pl))-a]--;            txt_cnt[((int)txt.charAt(idx))-a]++;                        if(Arrays.equals(pat_cnt,txt_cnt)){                res++;            }        }                return res;    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given a word pat and a text txt. Return the count of the occurences of anagrams of the word in the text.</p><h2 id=\"note\">Note</h2><ul>  <li>Check for substrings not subsequence or subset. <a href=\"https://www.geeksforgeeks.org/subarraysubstring-vs-subsequence-and-programs-to-generate-them/\">Read Here</a></li></ul><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span> <span class=\"o\">{</span>    <span class=\"kt\">int</span> <span class=\"nf\">search</span><span class=\"o\">(</span><span class=\"nc\">String</span> <span class=\"n\">pat</span><span class=\"o\">,</span> <span class=\"nc\">String</span> <span class=\"n\">txt</span><span class=\"o\">)</span> <span class=\"o\">{</span>        <span class=\"c1\">// code here</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">pat</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">()&gt;</span><span class=\"n\">txt</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">()){</span>            <span class=\"k\">return</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"kt\">int</span> <span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"o\">(</span><span class=\"kt\">int</span><span class=\"o\">)</span><span class=\"sc\">'a'</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">idx</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">pl</span> <span class=\"o\">=</span> <span class=\"n\">pat</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">();</span>        <span class=\"kt\">int</span> <span class=\"n\">tl</span> <span class=\"o\">=</span> <span class=\"n\">txt</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">();</span>                <span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">pat_cnt</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">int</span><span class=\"o\">[</span><span class=\"mi\">26</span><span class=\"o\">];</span>        <span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">txt_cnt</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">int</span><span class=\"o\">[</span><span class=\"mi\">26</span><span class=\"o\">];</span>                <span class=\"k\">for</span><span class=\"o\">(;</span><span class=\"n\">idx</span><span class=\"o\">&lt;</span><span class=\"n\">pl</span><span class=\"o\">;</span><span class=\"n\">idx</span><span class=\"o\">++){</span>            <span class=\"n\">pat_cnt</span><span class=\"o\">[((</span><span class=\"kt\">int</span><span class=\"o\">)</span><span class=\"n\">pat</span><span class=\"o\">.</span><span class=\"na\">charAt</span><span class=\"o\">(</span><span class=\"n\">idx</span><span class=\"o\">))-</span><span class=\"n\">a</span><span class=\"o\">]++;</span>            <span class=\"n\">txt_cnt</span><span class=\"o\">[((</span><span class=\"kt\">int</span><span class=\"o\">)</span><span class=\"n\">txt</span><span class=\"o\">.</span><span class=\"na\">charAt</span><span class=\"o\">(</span><span class=\"n\">idx</span><span class=\"o\">))-</span><span class=\"n\">a</span><span class=\"o\">]++;</span>        <span class=\"o\">}</span>                <span class=\"kt\">int</span> <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"nc\">Arrays</span><span class=\"o\">.</span><span class=\"na\">equals</span><span class=\"o\">(</span><span class=\"n\">pat_cnt</span><span class=\"o\">,</span><span class=\"n\">txt_cnt</span><span class=\"o\">)){</span>            <span class=\"n\">res</span><span class=\"o\">++;</span>        <span class=\"o\">}</span>                <span class=\"k\">for</span><span class=\"o\">(;</span><span class=\"n\">idx</span><span class=\"o\">&lt;</span><span class=\"n\">tl</span><span class=\"o\">;</span><span class=\"n\">idx</span><span class=\"o\">++){</span>            <span class=\"n\">txt_cnt</span><span class=\"o\">[((</span><span class=\"kt\">int</span><span class=\"o\">)</span><span class=\"n\">txt</span><span class=\"o\">.</span><span class=\"na\">charAt</span><span class=\"o\">(</span><span class=\"n\">idx</span><span class=\"o\">-</span><span class=\"n\">pl</span><span class=\"o\">))-</span><span class=\"n\">a</span><span class=\"o\">]--;</span>            <span class=\"n\">txt_cnt</span><span class=\"o\">[((</span><span class=\"kt\">int</span><span class=\"o\">)</span><span class=\"n\">txt</span><span class=\"o\">.</span><span class=\"na\">charAt</span><span class=\"o\">(</span><span class=\"n\">idx</span><span class=\"o\">))-</span><span class=\"n\">a</span><span class=\"o\">]++;</span>                        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"nc\">Arrays</span><span class=\"o\">.</span><span class=\"na\">equals</span><span class=\"o\">(</span><span class=\"n\">pat_cnt</span><span class=\"o\">,</span><span class=\"n\">txt_cnt</span><span class=\"o\">)){</span>                <span class=\"n\">res</span><span class=\"o\">++;</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>                <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/26/count-occurences-of-anagrams",
            
            
            
            "tags": ["gfg","potd","java","medium","note"],
            
            "date_published": "2021-09-26T00:00:00-05:00",
            "date_modified": "2021-09-26T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/25/largest-subarray-with-0-sum",
            "title": "Largest subarray with 0 sum",
            "summary": "Given an array having both positive and negative integers. The task is to compute the length of the largest subarray with sum 0.",
            "content_text": "Problem StatementGiven an array having both positive and negative integers. The task is to compute the length of the largest subarray with sum 0.Appris  Check whether the prefix sum has appeared earlier, cause  this shows the sum of values between current element and previous is equivalent to zeroSolutionclass GfG{    int maxLen(int arr[], int n){        // Your code here        Map&lt;Integer, Integer&gt; map = new HashMap&lt;&gt;();        int sum = 0;        map.put(sum,0);        sum+=arr[0];                int res = 0;        map.put(sum,1);                for(int i=1;i&lt;n;i++){            sum+=arr[i];            Integer val = map.get(sum);            if(val!=null){                res = Math.max(res,i-val+1);            }else{                map.put(sum,i+1);            }        }                return res;    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given an array having both positive and negative integers. The task is to compute the length of the largest subarray with sum 0.</p><h2 id=\"appris\">Appris</h2><ul>  <li>Check whether the prefix sum has appeared earlier, cause  this shows the sum of values between current element and previous is equivalent to zero</li></ul><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">GfG</span><span class=\"o\">{</span>    <span class=\"kt\">int</span> <span class=\"nf\">maxLen</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">arr</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">){</span>        <span class=\"c1\">// Your code here</span>        <span class=\"nc\">Map</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">,</span> <span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">map</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">HashMap</span><span class=\"o\">&lt;&gt;();</span>        <span class=\"kt\">int</span> <span class=\"n\">sum</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"n\">sum</span><span class=\"o\">,</span><span class=\"mi\">0</span><span class=\"o\">);</span>        <span class=\"n\">sum</span><span class=\"o\">+=</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"mi\">0</span><span class=\"o\">];</span>                <span class=\"kt\">int</span> <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"n\">sum</span><span class=\"o\">,</span><span class=\"mi\">1</span><span class=\"o\">);</span>                <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">1</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">n</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"n\">sum</span><span class=\"o\">+=</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">];</span>            <span class=\"nc\">Integer</span> <span class=\"n\">val</span> <span class=\"o\">=</span> <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">sum</span><span class=\"o\">);</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">val</span><span class=\"o\">!=</span><span class=\"kc\">null</span><span class=\"o\">){</span>                <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"nc\">Math</span><span class=\"o\">.</span><span class=\"na\">max</span><span class=\"o\">(</span><span class=\"n\">res</span><span class=\"o\">,</span><span class=\"n\">i</span><span class=\"o\">-</span><span class=\"n\">val</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">);</span>            <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>                <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"n\">sum</span><span class=\"o\">,</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">);</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>                <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/25/largest-subarray-with-0-sum",
            
            
            
            "tags": ["gfg","potd","java","easy","appris"],
            
            "date_published": "2021-09-25T00:00:00-05:00",
            "date_modified": "2021-09-25T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/24/check-tree-traversal",
            "title": "Check Tree Traversal",
            "summary": "Given Preorder, Inorder and Postorder traversals of some tree of size N. The task is to check if they are all of the same tree or not.",
            "content_text": "Problem StatementGiven Preorder, Inorder and Postorder traversals of some tree of size N. The task is to check if they are all of the same tree or not.NoteThis Soln is By Ayush Modihttps://auth.geeksforgeeks.org/user/ritumodi5/profileSolutionclass Tree{    int val;    Tree left, right;    Tree(int val){        this.val = val;        left = null; right = null;    }}class Solution{    static int idx;    static boolean isPossible;    static boolean checktree(int preorder[], int inorder[], int postorder[], int N){        idx = 0;        isPossible = true;        Map&lt;Integer, Integer&gt; hmap = new HashMap&lt;&gt;();        for(int i = 0; i &lt; inorder.length; i++) hmap.put(inorder[i], i);                Tree root = buildTree(inorder, preorder, hmap, 0, N-1);        if(!isPossible) return false;        List&lt;Integer&gt; post = new ArrayList&lt;&gt;();        buildPost(root, post);        return Arrays.equals(post.stream().mapToInt(i-&gt;i).toArray(), postorder);    }        private static void buildPost(Tree root, List&lt;Integer&gt; post){        if(root == null) return;        buildPost(root.left, post);        buildPost(root.right, post);        post.add(root.val);    }        private static Tree buildTree(int[] inorder, int[] preorder, Map&lt;Integer, Integer&gt; hmap, int start, int end){        if(start &gt; end) return null;        if(!isPossible) return null;        int val = preorder[idx++];        Tree root = new Tree(val);        if(!hmap.containsKey(val)){            isPossible = false;            return null;        }        int pos = hmap.get(val);        if(pos &lt; start || pos &gt; end){            isPossible = false;            return null;        }        root.left = buildTree(inorder, preorder, hmap, start, pos-1);        root.right = buildTree(inorder, preorder, hmap, pos+1, end);        return root;    }    }",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given Preorder, Inorder and Postorder traversals of some tree of size N. The task is to check if they are all of the same tree or not.</p><h3 id=\"note\">Note</h3><p>This Soln is By <code>Ayush Modi</code>https://auth.geeksforgeeks.org/user/ritumodi5/profile</p><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Tree</span><span class=\"o\">{</span>    <span class=\"kt\">int</span> <span class=\"n\">val</span><span class=\"o\">;</span>    <span class=\"nc\">Tree</span> <span class=\"n\">left</span><span class=\"o\">,</span> <span class=\"n\">right</span><span class=\"o\">;</span>    <span class=\"nc\">Tree</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">val</span><span class=\"o\">){</span>        <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">val</span> <span class=\"o\">=</span> <span class=\"n\">val</span><span class=\"o\">;</span>        <span class=\"n\">left</span> <span class=\"o\">=</span> <span class=\"kc\">null</span><span class=\"o\">;</span> <span class=\"n\">right</span> <span class=\"o\">=</span> <span class=\"kc\">null</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"n\">idx</span><span class=\"o\">;</span>    <span class=\"kd\">static</span> <span class=\"kt\">boolean</span> <span class=\"n\">isPossible</span><span class=\"o\">;</span>    <span class=\"kd\">static</span> <span class=\"kt\">boolean</span> <span class=\"nf\">checktree</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">preorder</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">inorder</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">postorder</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"no\">N</span><span class=\"o\">){</span>        <span class=\"n\">idx</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"n\">isPossible</span> <span class=\"o\">=</span> <span class=\"kc\">true</span><span class=\"o\">;</span>        <span class=\"nc\">Map</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">,</span> <span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">hmap</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">HashMap</span><span class=\"o\">&lt;&gt;();</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span> <span class=\"n\">i</span> <span class=\"o\">&lt;</span> <span class=\"n\">inorder</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">;</span> <span class=\"n\">i</span><span class=\"o\">++)</span> <span class=\"n\">hmap</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"n\">inorder</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">],</span> <span class=\"n\">i</span><span class=\"o\">);</span>                <span class=\"nc\">Tree</span> <span class=\"n\">root</span> <span class=\"o\">=</span> <span class=\"n\">buildTree</span><span class=\"o\">(</span><span class=\"n\">inorder</span><span class=\"o\">,</span> <span class=\"n\">preorder</span><span class=\"o\">,</span> <span class=\"n\">hmap</span><span class=\"o\">,</span> <span class=\"mi\">0</span><span class=\"o\">,</span> <span class=\"no\">N</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">);</span>        <span class=\"k\">if</span><span class=\"o\">(!</span><span class=\"n\">isPossible</span><span class=\"o\">)</span> <span class=\"k\">return</span> <span class=\"kc\">false</span><span class=\"o\">;</span>        <span class=\"nc\">List</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">post</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;&gt;();</span>        <span class=\"n\">buildPost</span><span class=\"o\">(</span><span class=\"n\">root</span><span class=\"o\">,</span> <span class=\"n\">post</span><span class=\"o\">);</span>        <span class=\"k\">return</span> <span class=\"nc\">Arrays</span><span class=\"o\">.</span><span class=\"na\">equals</span><span class=\"o\">(</span><span class=\"n\">post</span><span class=\"o\">.</span><span class=\"na\">stream</span><span class=\"o\">().</span><span class=\"na\">mapToInt</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">-&gt;</span><span class=\"n\">i</span><span class=\"o\">).</span><span class=\"na\">toArray</span><span class=\"o\">(),</span> <span class=\"n\">postorder</span><span class=\"o\">);</span>    <span class=\"o\">}</span>        <span class=\"kd\">private</span> <span class=\"kd\">static</span> <span class=\"kt\">void</span> <span class=\"nf\">buildPost</span><span class=\"o\">(</span><span class=\"nc\">Tree</span> <span class=\"n\">root</span><span class=\"o\">,</span> <span class=\"nc\">List</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">post</span><span class=\"o\">){</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">root</span> <span class=\"o\">==</span> <span class=\"kc\">null</span><span class=\"o\">)</span> <span class=\"k\">return</span><span class=\"o\">;</span>        <span class=\"n\">buildPost</span><span class=\"o\">(</span><span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">left</span><span class=\"o\">,</span> <span class=\"n\">post</span><span class=\"o\">);</span>        <span class=\"n\">buildPost</span><span class=\"o\">(</span><span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">right</span><span class=\"o\">,</span> <span class=\"n\">post</span><span class=\"o\">);</span>        <span class=\"n\">post</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">val</span><span class=\"o\">);</span>    <span class=\"o\">}</span>        <span class=\"kd\">private</span> <span class=\"kd\">static</span> <span class=\"nc\">Tree</span> <span class=\"nf\">buildTree</span><span class=\"o\">(</span><span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">inorder</span><span class=\"o\">,</span> <span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">preorder</span><span class=\"o\">,</span> <span class=\"nc\">Map</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">,</span> <span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">hmap</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">start</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">end</span><span class=\"o\">){</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">start</span> <span class=\"o\">&gt;</span> <span class=\"n\">end</span><span class=\"o\">)</span> <span class=\"k\">return</span> <span class=\"kc\">null</span><span class=\"o\">;</span>        <span class=\"k\">if</span><span class=\"o\">(!</span><span class=\"n\">isPossible</span><span class=\"o\">)</span> <span class=\"k\">return</span> <span class=\"kc\">null</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">val</span> <span class=\"o\">=</span> <span class=\"n\">preorder</span><span class=\"o\">[</span><span class=\"n\">idx</span><span class=\"o\">++];</span>        <span class=\"nc\">Tree</span> <span class=\"n\">root</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">Tree</span><span class=\"o\">(</span><span class=\"n\">val</span><span class=\"o\">);</span>        <span class=\"k\">if</span><span class=\"o\">(!</span><span class=\"n\">hmap</span><span class=\"o\">.</span><span class=\"na\">containsKey</span><span class=\"o\">(</span><span class=\"n\">val</span><span class=\"o\">)){</span>            <span class=\"n\">isPossible</span> <span class=\"o\">=</span> <span class=\"kc\">false</span><span class=\"o\">;</span>            <span class=\"k\">return</span> <span class=\"kc\">null</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"kt\">int</span> <span class=\"n\">pos</span> <span class=\"o\">=</span> <span class=\"n\">hmap</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">val</span><span class=\"o\">);</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">pos</span> <span class=\"o\">&lt;</span> <span class=\"n\">start</span> <span class=\"o\">||</span> <span class=\"n\">pos</span> <span class=\"o\">&gt;</span> <span class=\"n\">end</span><span class=\"o\">){</span>            <span class=\"n\">isPossible</span> <span class=\"o\">=</span> <span class=\"kc\">false</span><span class=\"o\">;</span>            <span class=\"k\">return</span> <span class=\"kc\">null</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">left</span> <span class=\"o\">=</span> <span class=\"n\">buildTree</span><span class=\"o\">(</span><span class=\"n\">inorder</span><span class=\"o\">,</span> <span class=\"n\">preorder</span><span class=\"o\">,</span> <span class=\"n\">hmap</span><span class=\"o\">,</span> <span class=\"n\">start</span><span class=\"o\">,</span> <span class=\"n\">pos</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">);</span>        <span class=\"n\">root</span><span class=\"o\">.</span><span class=\"na\">right</span> <span class=\"o\">=</span> <span class=\"n\">buildTree</span><span class=\"o\">(</span><span class=\"n\">inorder</span><span class=\"o\">,</span> <span class=\"n\">preorder</span><span class=\"o\">,</span> <span class=\"n\">hmap</span><span class=\"o\">,</span> <span class=\"n\">pos</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">,</span> <span class=\"n\">end</span><span class=\"o\">);</span>        <span class=\"k\">return</span> <span class=\"n\">root</span><span class=\"o\">;</span>    <span class=\"o\">}</span>    <span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/24/check-tree-traversal",
            
            
            
            "tags": ["gfg","potd","java","hard","note"],
            
            "date_published": "2021-09-24T00:00:00-05:00",
            "date_modified": "2021-09-24T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/23/count-total-set-bits",
            "title": "Count total set bits",
            "summary": "You are given a number N. Find the total count of set bits for all numbers from 1 to N(both inclusive).",
            "content_text": "Problem StatementYou are given a number N. Find the total count of set bits for all numbers from 1 to N(both inclusive).Solutionclass Solution{        public static int log2(int N){          // calculate log2 N indirectly        // using log() method        int result = (int)Math.floor(Math.log(N) / Math.log(2));        return result;    }        //Function to return sum of count of set bits in the integers from 1 to n.    public static int countSetBits(int n){        // Your code here        if((n&amp;(n-1)) == 0){            //if n is power of 2 directly return result            return 1+ log2(n)*(n/2);       }else{           // y is 2th power  before n           int y =(int) Math.pow(2,log2(n));           return (n-y) + countSetBits(y)+ countSetBits(n-y);       }    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>You are given a number N. Find the total count of set bits for all numbers from 1 to N(both inclusive).</p><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>        <span class=\"kd\">public</span> <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"nf\">log2</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"no\">N</span><span class=\"o\">){</span>          <span class=\"c1\">// calculate log2 N indirectly</span>        <span class=\"c1\">// using log() method</span>        <span class=\"kt\">int</span> <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"o\">(</span><span class=\"kt\">int</span><span class=\"o\">)</span><span class=\"nc\">Math</span><span class=\"o\">.</span><span class=\"na\">floor</span><span class=\"o\">(</span><span class=\"nc\">Math</span><span class=\"o\">.</span><span class=\"na\">log</span><span class=\"o\">(</span><span class=\"no\">N</span><span class=\"o\">)</span> <span class=\"o\">/</span> <span class=\"nc\">Math</span><span class=\"o\">.</span><span class=\"na\">log</span><span class=\"o\">(</span><span class=\"mi\">2</span><span class=\"o\">));</span>        <span class=\"k\">return</span> <span class=\"n\">result</span><span class=\"o\">;</span>    <span class=\"o\">}</span>        <span class=\"c1\">//Function to return sum of count of set bits in the integers from 1 to n.</span>    <span class=\"kd\">public</span> <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"nf\">countSetBits</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">){</span>        <span class=\"c1\">// Your code here</span>        <span class=\"k\">if</span><span class=\"o\">((</span><span class=\"n\">n</span><span class=\"o\">&amp;(</span><span class=\"n\">n</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">))</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"o\">){</span>            <span class=\"c1\">//if n is power of 2 directly return result</span>            <span class=\"k\">return</span> <span class=\"mi\">1</span><span class=\"o\">+</span> <span class=\"n\">log2</span><span class=\"o\">(</span><span class=\"n\">n</span><span class=\"o\">)*(</span><span class=\"n\">n</span><span class=\"o\">/</span><span class=\"mi\">2</span><span class=\"o\">);</span>       <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>           <span class=\"c1\">// y is 2th power  before n</span>           <span class=\"kt\">int</span> <span class=\"n\">y</span> <span class=\"o\">=(</span><span class=\"kt\">int</span><span class=\"o\">)</span> <span class=\"nc\">Math</span><span class=\"o\">.</span><span class=\"na\">pow</span><span class=\"o\">(</span><span class=\"mi\">2</span><span class=\"o\">,</span><span class=\"n\">log2</span><span class=\"o\">(</span><span class=\"n\">n</span><span class=\"o\">));</span>           <span class=\"k\">return</span> <span class=\"o\">(</span><span class=\"n\">n</span><span class=\"o\">-</span><span class=\"n\">y</span><span class=\"o\">)</span> <span class=\"o\">+</span> <span class=\"n\">countSetBits</span><span class=\"o\">(</span><span class=\"n\">y</span><span class=\"o\">)+</span> <span class=\"n\">countSetBits</span><span class=\"o\">(</span><span class=\"n\">n</span><span class=\"o\">-</span><span class=\"n\">y</span><span class=\"o\">);</span>       <span class=\"o\">}</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/23/count-total-set-bits",
            
            
            
            "tags": ["gfg","potd","java","medium"],
            
            "date_published": "2021-09-23T00:00:00-05:00",
            "date_modified": "2021-09-23T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/22/repeated-string-match",
            "title": "Repeated String Match",
            "summary": "Given two strings A and B, find the minimum number of times A has to be repeated such that B becomes a substring of the repeated A. If B cannot be a substring of A no matter how many times it is repeated, return -1.",
            "content_text": "Problem StatementGiven two strings A and B, find the minimum number of times A has to be repeated such that B becomes a substring of the repeated A. If B cannot be a substring of A no matter how many times it is repeated, return -1.Appris  String questions, Python is goto.Solutionclass Solution:    def repeatedStringMatch(self, A, B):        # code here        cnt = 1        S = A;        while(len(B) &gt; len(S)):            S+=A            cnt+=1        if B in S:            return cnt        if B in S+A:            return cnt+1        return -1;",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given two strings A and B, find the minimum number of times A has to be repeated such that B becomes a substring of the repeated A. If B cannot be a substring of A no matter how many times it is repeated, return -1.</p><h2 id=\"appris\">Appris</h2><ul>  <li>String questions, Python is goto.</li></ul><h3 id=\"solution\">Solution</h3><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"k\">class</span> <span class=\"nc\">Solution</span><span class=\"p\">:</span>    <span class=\"k\">def</span> <span class=\"nf\">repeatedStringMatch</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">A</span><span class=\"p\">,</span> <span class=\"n\">B</span><span class=\"p\">):</span>        <span class=\"c1\"># code here</span>        <span class=\"n\">cnt</span> <span class=\"o\">=</span> <span class=\"mi\">1</span>        <span class=\"n\">S</span> <span class=\"o\">=</span> <span class=\"n\">A</span><span class=\"p\">;</span>        <span class=\"k\">while</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">B</span><span class=\"p\">)</span> <span class=\"o\">&gt;</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)):</span>            <span class=\"n\">S</span><span class=\"o\">+=</span><span class=\"n\">A</span>            <span class=\"n\">cnt</span><span class=\"o\">+=</span><span class=\"mi\">1</span>        <span class=\"k\">if</span> <span class=\"n\">B</span> <span class=\"ow\">in</span> <span class=\"n\">S</span><span class=\"p\">:</span>            <span class=\"k\">return</span> <span class=\"n\">cnt</span>        <span class=\"k\">if</span> <span class=\"n\">B</span> <span class=\"ow\">in</span> <span class=\"n\">S</span><span class=\"o\">+</span><span class=\"n\">A</span><span class=\"p\">:</span>            <span class=\"k\">return</span> <span class=\"n\">cnt</span><span class=\"o\">+</span><span class=\"mi\">1</span>        <span class=\"k\">return</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">;</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/22/repeated-string-match",
            
            
            
            "tags": ["gfg","potd","python","medium","appris"],
            
            "date_published": "2021-09-22T00:00:00-05:00",
            "date_modified": "2021-09-22T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/21/dam-of-candies",
            "title": "Dam of Candies",
            "summary": "Geek wants to make a special space for candies on his bookshelf. Currently, it has N books, each of whose height is represented by the array height[] and has unit width. Help him select 2 books such that he can store maximum candies between them by removing all the other books from between the selected books. The task is to find out the area between two books that can hold the maximum candies without changing the original position of selected books",
            "content_text": "Problem StatementGeek wants to make a special space for candies on his bookshelf. Currently, it has N books, each of whose height is represented by the array height[] and has unit width.Help him select 2 books such that he can store maximum candies between them by removing all the other books from between the selected books. The task is to find out the area between two books that can hold the maximum candies without changing the original position of selected booksSolution class Solution:    def maxCandy(self, height, n):         # Your code goes here        maximum=0;        f=0        l=n-1        while(f&lt;l):            if height[f]&lt;height[l]:                maximum=max(maximum,(l-f-1)*height[f])                f+=1            else:                maximum=max(maximum,(l-f-1)*height[l])                l-=1        return maximum",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Geek wants to make a special space for candies on his bookshelf. Currently, it has N books, each of whose height is represented by the array height[] and has unit width.Help him select 2 books such that he can store maximum candies between them by removing all the other books from between the selected books. The task is to find out the area between two books that can hold the maximum candies without changing the original position of selected books</p><h3 id=\"solution\">Solution</h3><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code> <span class=\"k\">class</span> <span class=\"nc\">Solution</span><span class=\"p\">:</span>    <span class=\"k\">def</span> <span class=\"nf\">maxCandy</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">height</span><span class=\"p\">,</span> <span class=\"n\">n</span><span class=\"p\">):</span>         <span class=\"c1\"># Your code goes here</span>        <span class=\"n\">maximum</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"p\">;</span>        <span class=\"n\">f</span><span class=\"o\">=</span><span class=\"mi\">0</span>        <span class=\"n\">l</span><span class=\"o\">=</span><span class=\"n\">n</span><span class=\"o\">-</span><span class=\"mi\">1</span>        <span class=\"k\">while</span><span class=\"p\">(</span><span class=\"n\">f</span><span class=\"o\">&lt;</span><span class=\"n\">l</span><span class=\"p\">):</span>            <span class=\"k\">if</span> <span class=\"n\">height</span><span class=\"p\">[</span><span class=\"n\">f</span><span class=\"p\">]</span><span class=\"o\">&lt;</span><span class=\"n\">height</span><span class=\"p\">[</span><span class=\"n\">l</span><span class=\"p\">]:</span>                <span class=\"n\">maximum</span><span class=\"o\">=</span><span class=\"nb\">max</span><span class=\"p\">(</span><span class=\"n\">maximum</span><span class=\"p\">,(</span><span class=\"n\">l</span><span class=\"o\">-</span><span class=\"n\">f</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">)</span><span class=\"o\">*</span><span class=\"n\">height</span><span class=\"p\">[</span><span class=\"n\">f</span><span class=\"p\">])</span>                <span class=\"n\">f</span><span class=\"o\">+=</span><span class=\"mi\">1</span>            <span class=\"k\">else</span><span class=\"p\">:</span>                <span class=\"n\">maximum</span><span class=\"o\">=</span><span class=\"nb\">max</span><span class=\"p\">(</span><span class=\"n\">maximum</span><span class=\"p\">,(</span><span class=\"n\">l</span><span class=\"o\">-</span><span class=\"n\">f</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">)</span><span class=\"o\">*</span><span class=\"n\">height</span><span class=\"p\">[</span><span class=\"n\">l</span><span class=\"p\">])</span>                <span class=\"n\">l</span><span class=\"o\">-=</span><span class=\"mi\">1</span>        <span class=\"k\">return</span> <span class=\"n\">maximum</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/21/dam-of-candies",
            
            
            
            "tags": ["gfg","potd","python","medium"],
            
            "date_published": "2021-09-21T00:00:00-05:00",
            "date_modified": "2021-09-21T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/20/factorials-of-large-numbers",
            "title": "Factorials of large numbers",
            "summary": "Given an integer N, find its factorial.",
            "content_text": "Problem StatementGiven an integer N, find its factorial.Appris  Python is better for these types of problems, datatype overflow will not be an issue.  Integers in Python 3 are limited only by available memory. Python 2 had two integer types - int and long. They are unified from Python 3.  BigInteger is an 0ption in JavaEdge Case  Factorial problems, look for corner cases of the input range. Look for overflow and run-time errors.      1            2            50      SolutionJavaclass Solution {    static void arrayMultiplication(ArrayList&lt;Integer&gt; res, int factor){        int carry = 0;        for(int i=res.size()-1;i&gt;=0;i--){            int temp = res.get(i)*factor + carry;            res.set(i, temp%10);            carry = temp/10;        }        while(carry&gt;0){            res.add(0,carry%10);            carry = carry/10;        }    }        static ArrayList&lt;Integer&gt; factorial(int N){        //code here        ArrayList&lt;Integer&gt; res = new ArrayList&lt;Integer&gt;();        if(N==1 || N==2){            res.add(N);            return res;        }                res.add(2);        for(int i=3;i&lt;=N;i++){            arrayMultiplication(res,i);        }                return res;    }}Pythonclass Solution:    def factorial(self, N):        #code here        temp = 1        for i in range(1,N+1):            temp*=i;                res = []        for i in str(temp):            res.append(i)        return res;",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given an integer N, find its factorial.</p><h2 id=\"appris\">Appris</h2><ul>  <li>Python is better for these types of problems, datatype overflow will not be an issue.</li>  <li>Integers in Python 3 are limited only by available memory. Python 2 had two integer types - int and long. They are unified from Python 3.</li>  <li>BigInteger is an 0ption in Java</li></ul><h2 id=\"edge-case\">Edge Case</h2><ul>  <li>Factorial problems, look for corner cases of the input range. Look for overflow and run-time errors.</li></ul><ol>  <li>    <div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>1</code></pre></div>    </div>  </li>  <li>    <div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>2</code></pre></div>    </div>  </li>  <li>    <div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>50</code></pre></div>    </div>  </li></ol><h3 id=\"solution\">Solution</h3><h4 id=\"java\">Java</h4><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span> <span class=\"o\">{</span>    <span class=\"kd\">static</span> <span class=\"kt\">void</span> <span class=\"nf\">arrayMultiplication</span><span class=\"o\">(</span><span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">res</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">factor</span><span class=\"o\">){</span>        <span class=\"kt\">int</span> <span class=\"n\">carry</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()-</span><span class=\"mi\">1</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&gt;=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">--){</span>            <span class=\"kt\">int</span> <span class=\"n\">temp</span> <span class=\"o\">=</span> <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">)*</span><span class=\"n\">factor</span> <span class=\"o\">+</span> <span class=\"n\">carry</span><span class=\"o\">;</span>            <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">set</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">,</span> <span class=\"n\">temp</span><span class=\"o\">%</span><span class=\"mi\">10</span><span class=\"o\">);</span>            <span class=\"n\">carry</span> <span class=\"o\">=</span> <span class=\"n\">temp</span><span class=\"o\">/</span><span class=\"mi\">10</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">carry</span><span class=\"o\">&gt;</span><span class=\"mi\">0</span><span class=\"o\">){</span>            <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"mi\">0</span><span class=\"o\">,</span><span class=\"n\">carry</span><span class=\"o\">%</span><span class=\"mi\">10</span><span class=\"o\">);</span>            <span class=\"n\">carry</span> <span class=\"o\">=</span> <span class=\"n\">carry</span><span class=\"o\">/</span><span class=\"mi\">10</span><span class=\"o\">;</span>        <span class=\"o\">}</span>    <span class=\"o\">}</span>        <span class=\"kd\">static</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"nf\">factorial</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"no\">N</span><span class=\"o\">){</span>        <span class=\"c1\">//code here</span>        <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;();</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"no\">N</span><span class=\"o\">==</span><span class=\"mi\">1</span> <span class=\"o\">||</span> <span class=\"no\">N</span><span class=\"o\">==</span><span class=\"mi\">2</span><span class=\"o\">){</span>            <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"no\">N</span><span class=\"o\">);</span>            <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>        <span class=\"o\">}</span>                <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"mi\">2</span><span class=\"o\">);</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">3</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;=</span><span class=\"no\">N</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"n\">arrayMultiplication</span><span class=\"o\">(</span><span class=\"n\">res</span><span class=\"o\">,</span><span class=\"n\">i</span><span class=\"o\">);</span>        <span class=\"o\">}</span>                <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div><h4 id=\"python\">Python</h4><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"k\">class</span> <span class=\"nc\">Solution</span><span class=\"p\">:</span>    <span class=\"k\">def</span> <span class=\"nf\">factorial</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">N</span><span class=\"p\">):</span>        <span class=\"c1\">#code here</span>        <span class=\"n\">temp</span> <span class=\"o\">=</span> <span class=\"mi\">1</span>        <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span><span class=\"n\">N</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"p\">):</span>            <span class=\"n\">temp</span><span class=\"o\">*=</span><span class=\"n\">i</span><span class=\"p\">;</span>                <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>        <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"n\">temp</span><span class=\"p\">):</span>            <span class=\"n\">res</span><span class=\"p\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">i</span><span class=\"p\">)</span>        <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"p\">;</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/20/factorials-of-large-numbers",
            
            
            
            "tags": ["gfg","potd","java","python","medium","appris","edge_case"],
            
            "date_published": "2021-09-20T00:00:00-05:00",
            "date_modified": "2021-09-20T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/19/median-of-2-sorted-arrays-of-different-sizes",
            "title": "Median of 2 Sorted Arrays of Different Sizes",
            "summary": "Given two sorted arrays array1 and array2 of size m and n respectively. Find the median of the two sorted arrays.",
            "content_text": "Problem StatementGiven two sorted arrays array1 and array2 of size m and n respectively. Find the median of the two sorted arrays.Appris  In Python, it is important have integer decimal, as integer itself    5.0 -&gt; 55.1 -&gt; 5.1         In Java, Divide by double to convert the return into double, rather than type conversion.Note  The naive approach would be to merge the two arrays and return the median element(s).  But for the naive method, there is a lot of overhead. We only need the midst element(s). So we could do what we do in merge sort, iterate over the two arrays and have a counter to reach the middle element(s).  This can be achieved in serval ways, one of which is to create an auxiliary array of size (m + n) /2 +1. (We only need the middle element(s)). Therefore this space is more than enough.  But I believe this can be further optimized, by only storing one extra element, in the case of an even number of elements.May reduce the space complexity but not the complexity, cause a check to be done several timesEdge Case  Look for Odd and Even number of elements. Check explicitly for even number of total elements41 2 3 465 6 7 8 9 101412SolutionJavaclass GFG {     static double medianOfArrays(int n, int m, int a[], int b[])     {        // Your Code Here        int mid = ((n+m)/2)+1;        int[] arr = new int[mid];                int i=0,j=0,k=0;                while(k&lt;mid &amp;&amp; i&lt;n &amp;&amp; j&lt;m ){            if(a[i]&lt;=b[j]){                arr[k++]=a[i++];            }else{                arr[k++]=b[j++];            }        }                while(k&lt;mid &amp;&amp; i&lt;n){            arr[k++]=a[i++];        }                while(k&lt;mid &amp;&amp; j&lt;m){            arr[k++]=b[j++];        }                if((n+m)%2==1){            return arr[mid-1];        }else{            return (arr[mid-1] + arr[mid-2])/2.0;        }    }}Pythonclass Solution:    def MedianOfArrays(self, array1, array2):        #code here        \"\"\"        Naive approach        \"\"\"        a = array1+array2        a.sort();                n = len(a);        if(n%2==0):            val = (a[n//2]+a[n//2-1])/2            if int(val)!=val:                return val            else:                return int(val);        else:            return a[n//2];",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given two sorted arrays array1 and array2 of size m and n respectively. Find the median of the two sorted arrays.</p><h2 id=\"appris\">Appris</h2><ul>  <li>In Python, it is important have integer decimal, as integer itself    <div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>5.0 -&gt; 55.1 -&gt; 5.1 </code></pre></div>    </div>  </li>  <li>In Java, Divide by double to convert the return into double, rather than type conversion.</li></ul><h2 id=\"note\">Note</h2><ul>  <li>The naive approach would be to merge the two arrays and return the median element(s).</li>  <li>But for the naive method, there is a lot of overhead. We only need the midst element(s). So we could do what we do in merge sort, iterate over the two arrays and have a counter to reach the middle element(s).</li>  <li>This can be achieved in serval ways, one of which is to create an auxiliary array of size (m + n) /2 +1. (We only need the middle element(s)). Therefore this space is more than enough.</li>  <li>But I believe this can be further optimized, by only storing one extra element, in the case of an even number of elements.May reduce the space complexity but not the complexity, cause a check to be done several times</li></ul><h2 id=\"edge-case\">Edge Case</h2><ul>  <li>Look for <code>Odd</code> and <code>Even</code> number of elements. Check explicitly for even number of total elements</li></ul><div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>41 2 3 465 6 7 8 9 10</code></pre></div></div><div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>1412</code></pre></div></div><h2 id=\"solution\">Solution</h2><h3 id=\"java\">Java</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">GFG</span> <span class=\"o\">{</span>     <span class=\"kd\">static</span> <span class=\"kt\">double</span> <span class=\"nf\">medianOfArrays</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">m</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">a</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">b</span><span class=\"o\">[])</span>     <span class=\"o\">{</span>        <span class=\"c1\">// Your Code Here</span>        <span class=\"kt\">int</span> <span class=\"n\">mid</span> <span class=\"o\">=</span> <span class=\"o\">((</span><span class=\"n\">n</span><span class=\"o\">+</span><span class=\"n\">m</span><span class=\"o\">)/</span><span class=\"mi\">2</span><span class=\"o\">)+</span><span class=\"mi\">1</span><span class=\"o\">;</span>        <span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">arr</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">int</span><span class=\"o\">[</span><span class=\"n\">mid</span><span class=\"o\">];</span>                <span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">,</span><span class=\"n\">j</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">,</span><span class=\"n\">k</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span>                <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">k</span><span class=\"o\">&lt;</span><span class=\"n\">mid</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">n</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">j</span><span class=\"o\">&lt;</span><span class=\"n\">m</span> <span class=\"o\">){</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">a</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]&lt;=</span><span class=\"n\">b</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">]){</span>                <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">k</span><span class=\"o\">++]=</span><span class=\"n\">a</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">++];</span>            <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>                <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">k</span><span class=\"o\">++]=</span><span class=\"n\">b</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">++];</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>                <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">k</span><span class=\"o\">&lt;</span><span class=\"n\">mid</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">n</span><span class=\"o\">){</span>            <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">k</span><span class=\"o\">++]=</span><span class=\"n\">a</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">++];</span>        <span class=\"o\">}</span>                <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">k</span><span class=\"o\">&lt;</span><span class=\"n\">mid</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">j</span><span class=\"o\">&lt;</span><span class=\"n\">m</span><span class=\"o\">){</span>            <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">k</span><span class=\"o\">++]=</span><span class=\"n\">b</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">++];</span>        <span class=\"o\">}</span>                <span class=\"k\">if</span><span class=\"o\">((</span><span class=\"n\">n</span><span class=\"o\">+</span><span class=\"n\">m</span><span class=\"o\">)%</span><span class=\"mi\">2</span><span class=\"o\">==</span><span class=\"mi\">1</span><span class=\"o\">){</span>            <span class=\"k\">return</span> <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">mid</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">];</span>        <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>            <span class=\"k\">return</span> <span class=\"o\">(</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">mid</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">]</span> <span class=\"o\">+</span> <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">mid</span><span class=\"o\">-</span><span class=\"mi\">2</span><span class=\"o\">])/</span><span class=\"mf\">2.0</span><span class=\"o\">;</span>        <span class=\"o\">}</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div><h4 id=\"python\">Python</h4><div class=\"language-python highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"k\">class</span> <span class=\"nc\">Solution</span><span class=\"p\">:</span>    <span class=\"k\">def</span> <span class=\"nf\">MedianOfArrays</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">array1</span><span class=\"p\">,</span> <span class=\"n\">array2</span><span class=\"p\">):</span>        <span class=\"c1\">#code here</span>        <span class=\"s\">\"\"\"        Naive approach        \"\"\"</span>        <span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"n\">array1</span><span class=\"o\">+</span><span class=\"n\">array2</span>        <span class=\"n\">a</span><span class=\"p\">.</span><span class=\"n\">sort</span><span class=\"p\">();</span>                <span class=\"n\">n</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">);</span>        <span class=\"k\">if</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"o\">%</span><span class=\"mi\">2</span><span class=\"o\">==</span><span class=\"mi\">0</span><span class=\"p\">):</span>            <span class=\"n\">val</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">[</span><span class=\"n\">n</span><span class=\"o\">//</span><span class=\"mi\">2</span><span class=\"p\">]</span><span class=\"o\">+</span><span class=\"n\">a</span><span class=\"p\">[</span><span class=\"n\">n</span><span class=\"o\">//</span><span class=\"mi\">2</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">])</span><span class=\"o\">/</span><span class=\"mi\">2</span>            <span class=\"k\">if</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"n\">val</span><span class=\"p\">)</span><span class=\"o\">!=</span><span class=\"n\">val</span><span class=\"p\">:</span>                <span class=\"k\">return</span> <span class=\"n\">val</span>            <span class=\"k\">else</span><span class=\"p\">:</span>                <span class=\"k\">return</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"n\">val</span><span class=\"p\">);</span>        <span class=\"k\">else</span><span class=\"p\">:</span>            <span class=\"k\">return</span> <span class=\"n\">a</span><span class=\"p\">[</span><span class=\"n\">n</span><span class=\"o\">//</span><span class=\"mi\">2</span><span class=\"p\">];</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/19/median-of-2-sorted-arrays-of-different-sizes",
            
            
            
            "tags": ["gfg","potd","java","python","hard","appris","edge_case","note"],
            
            "date_published": "2021-09-19T00:00:00-05:00",
            "date_modified": "2021-09-19T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/19/expression-add-operators",
            "title": "Expression Add Operators",
            "summary": "Given a string num that contains only digits and an integer target, return all possibilities to add the binary operators '+', '-', or '*' between the digits of num so that the resultant expression evaluates to the target value.",
            "content_text": "Problem StatementGiven a string num that contains only digits and an integer target, return all possibilities to add the binary operators ‘+’, ‘-‘, or ‘*’ between the digits of num so that the resultant expression evaluates to the target value.Edge Case  10-5, this should give a hint of an option of no operation is also an operation    Input: num = \"105\", target = 5Output: [\"1*0+5\",\"10-5\"]      Appris  String Builder preety much works like python list.Note  This the officail solution given by leetcode editorialSolutionclass Solution {  public ArrayList&lt;String&gt; answer;  public String digits;  public long target;  public void recurse(      int index, long previousOperand, long currentOperand, long value, ArrayList&lt;String&gt; ops) {    String nums = this.digits;    // Done processing all the digits in num    if (index == nums.length()) {      // If the final value == target expected AND      // no operand is left unprocessed      if (value == this.target &amp;&amp; currentOperand == 0) {        StringBuilder sb = new StringBuilder();        ops.subList(1, ops.size()).forEach(v -&gt; sb.append(v));        this.answer.add(sb.toString());      }      return;    }    // Extending the current operand by one digit    currentOperand = currentOperand * 10 + Character.getNumericValue(nums.charAt(index));    String current_val_rep = Long.toString(currentOperand);    int length = nums.length();    // To avoid cases where we have 1 + 05 or 1 * 05 since 05 won't be a    // valid operand. Hence this check    if (currentOperand &gt; 0) {      // NO OP recursion      recurse(index + 1, previousOperand, currentOperand, value, ops);    }    // ADDITION    ops.add(\"+\");    ops.add(current_val_rep);    recurse(index + 1, currentOperand, 0, value + currentOperand, ops);    ops.remove(ops.size() - 1);    ops.remove(ops.size() - 1);    if (ops.size() &gt; 0) {      // SUBTRACTION      ops.add(\"-\");      ops.add(current_val_rep);      recurse(index + 1, -currentOperand, 0, value - currentOperand, ops);      ops.remove(ops.size() - 1);      ops.remove(ops.size() - 1);      // MULTIPLICATION      ops.add(\"*\");      ops.add(current_val_rep);      recurse(          index + 1,          currentOperand * previousOperand,          0,          value - previousOperand + (currentOperand * previousOperand),          ops);      ops.remove(ops.size() - 1);      ops.remove(ops.size() - 1);    }  }  public List&lt;String&gt; addOperators(String num, int target) {    if (num.length() == 0) {      return new ArrayList&lt;String&gt;();    }    this.target = target;    this.digits = num;    this.answer = new ArrayList&lt;String&gt;();    this.recurse(0, 0, 0, 0, new ArrayList&lt;String&gt;());    return this.answer;  }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given a string num that contains only digits and an integer target, return all possibilities to add the binary operators ‘+’, ‘-‘, or ‘*’ between the digits of num so that the resultant expression evaluates to the target value.</p><h2 id=\"edge-case\">Edge Case</h2><ul>  <li><code>10-5</code>, this should give a hint of an option of no operation is also an operation    <div class=\"language-plaintext highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>Input: num = \"105\", target = 5Output: [\"1*0+5\",\"10-5\"]</code></pre></div>    </div>  </li></ul><h2 id=\"appris\">Appris</h2><ul>  <li>String Builder preety much works like python list.</li></ul><h2 id=\"note\">Note</h2><ul>  <li>This the officail solution given by leetcode editorial</li></ul><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span> <span class=\"o\">{</span>  <span class=\"kd\">public</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">String</span><span class=\"o\">&gt;</span> <span class=\"n\">answer</span><span class=\"o\">;</span>  <span class=\"kd\">public</span> <span class=\"nc\">String</span> <span class=\"n\">digits</span><span class=\"o\">;</span>  <span class=\"kd\">public</span> <span class=\"kt\">long</span> <span class=\"n\">target</span><span class=\"o\">;</span>  <span class=\"kd\">public</span> <span class=\"kt\">void</span> <span class=\"nf\">recurse</span><span class=\"o\">(</span>      <span class=\"kt\">int</span> <span class=\"n\">index</span><span class=\"o\">,</span> <span class=\"kt\">long</span> <span class=\"n\">previousOperand</span><span class=\"o\">,</span> <span class=\"kt\">long</span> <span class=\"n\">currentOperand</span><span class=\"o\">,</span> <span class=\"kt\">long</span> <span class=\"n\">value</span><span class=\"o\">,</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">String</span><span class=\"o\">&gt;</span> <span class=\"n\">ops</span><span class=\"o\">)</span> <span class=\"o\">{</span>    <span class=\"nc\">String</span> <span class=\"n\">nums</span> <span class=\"o\">=</span> <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">digits</span><span class=\"o\">;</span>    <span class=\"c1\">// Done processing all the digits in num</span>    <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">index</span> <span class=\"o\">==</span> <span class=\"n\">nums</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">())</span> <span class=\"o\">{</span>      <span class=\"c1\">// If the final value == target expected AND</span>      <span class=\"c1\">// no operand is left unprocessed</span>      <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">value</span> <span class=\"o\">==</span> <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">target</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">currentOperand</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"o\">)</span> <span class=\"o\">{</span>        <span class=\"nc\">StringBuilder</span> <span class=\"n\">sb</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">StringBuilder</span><span class=\"o\">();</span>        <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">subList</span><span class=\"o\">(</span><span class=\"mi\">1</span><span class=\"o\">,</span> <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()).</span><span class=\"na\">forEach</span><span class=\"o\">(</span><span class=\"n\">v</span> <span class=\"o\">-&gt;</span> <span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">append</span><span class=\"o\">(</span><span class=\"n\">v</span><span class=\"o\">));</span>        <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">answer</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">sb</span><span class=\"o\">.</span><span class=\"na\">toString</span><span class=\"o\">());</span>      <span class=\"o\">}</span>      <span class=\"k\">return</span><span class=\"o\">;</span>    <span class=\"o\">}</span>    <span class=\"c1\">// Extending the current operand by one digit</span>    <span class=\"n\">currentOperand</span> <span class=\"o\">=</span> <span class=\"n\">currentOperand</span> <span class=\"o\">*</span> <span class=\"mi\">10</span> <span class=\"o\">+</span> <span class=\"nc\">Character</span><span class=\"o\">.</span><span class=\"na\">getNumericValue</span><span class=\"o\">(</span><span class=\"n\">nums</span><span class=\"o\">.</span><span class=\"na\">charAt</span><span class=\"o\">(</span><span class=\"n\">index</span><span class=\"o\">));</span>    <span class=\"nc\">String</span> <span class=\"n\">current_val_rep</span> <span class=\"o\">=</span> <span class=\"nc\">Long</span><span class=\"o\">.</span><span class=\"na\">toString</span><span class=\"o\">(</span><span class=\"n\">currentOperand</span><span class=\"o\">);</span>    <span class=\"kt\">int</span> <span class=\"n\">length</span> <span class=\"o\">=</span> <span class=\"n\">nums</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">();</span>    <span class=\"c1\">// To avoid cases where we have 1 + 05 or 1 * 05 since 05 won't be a</span>    <span class=\"c1\">// valid operand. Hence this check</span>    <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">currentOperand</span> <span class=\"o\">&gt;</span> <span class=\"mi\">0</span><span class=\"o\">)</span> <span class=\"o\">{</span>      <span class=\"c1\">// NO OP recursion</span>      <span class=\"n\">recurse</span><span class=\"o\">(</span><span class=\"n\">index</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"o\">,</span> <span class=\"n\">previousOperand</span><span class=\"o\">,</span> <span class=\"n\">currentOperand</span><span class=\"o\">,</span> <span class=\"n\">value</span><span class=\"o\">,</span> <span class=\"n\">ops</span><span class=\"o\">);</span>    <span class=\"o\">}</span>    <span class=\"c1\">// ADDITION</span>    <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"s\">\"+\"</span><span class=\"o\">);</span>    <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">current_val_rep</span><span class=\"o\">);</span>    <span class=\"n\">recurse</span><span class=\"o\">(</span><span class=\"n\">index</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"o\">,</span> <span class=\"n\">currentOperand</span><span class=\"o\">,</span> <span class=\"mi\">0</span><span class=\"o\">,</span> <span class=\"n\">value</span> <span class=\"o\">+</span> <span class=\"n\">currentOperand</span><span class=\"o\">,</span> <span class=\"n\">ops</span><span class=\"o\">);</span>    <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">remove</span><span class=\"o\">(</span><span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()</span> <span class=\"o\">-</span> <span class=\"mi\">1</span><span class=\"o\">);</span>    <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">remove</span><span class=\"o\">(</span><span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()</span> <span class=\"o\">-</span> <span class=\"mi\">1</span><span class=\"o\">);</span>    <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()</span> <span class=\"o\">&gt;</span> <span class=\"mi\">0</span><span class=\"o\">)</span> <span class=\"o\">{</span>      <span class=\"c1\">// SUBTRACTION</span>      <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"s\">\"-\"</span><span class=\"o\">);</span>      <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">current_val_rep</span><span class=\"o\">);</span>      <span class=\"n\">recurse</span><span class=\"o\">(</span><span class=\"n\">index</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"o\">,</span> <span class=\"o\">-</span><span class=\"n\">currentOperand</span><span class=\"o\">,</span> <span class=\"mi\">0</span><span class=\"o\">,</span> <span class=\"n\">value</span> <span class=\"o\">-</span> <span class=\"n\">currentOperand</span><span class=\"o\">,</span> <span class=\"n\">ops</span><span class=\"o\">);</span>      <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">remove</span><span class=\"o\">(</span><span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()</span> <span class=\"o\">-</span> <span class=\"mi\">1</span><span class=\"o\">);</span>      <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">remove</span><span class=\"o\">(</span><span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()</span> <span class=\"o\">-</span> <span class=\"mi\">1</span><span class=\"o\">);</span>      <span class=\"c1\">// MULTIPLICATION</span>      <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"s\">\"*\"</span><span class=\"o\">);</span>      <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">current_val_rep</span><span class=\"o\">);</span>      <span class=\"n\">recurse</span><span class=\"o\">(</span>          <span class=\"n\">index</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"o\">,</span>          <span class=\"n\">currentOperand</span> <span class=\"o\">*</span> <span class=\"n\">previousOperand</span><span class=\"o\">,</span>          <span class=\"mi\">0</span><span class=\"o\">,</span>          <span class=\"n\">value</span> <span class=\"o\">-</span> <span class=\"n\">previousOperand</span> <span class=\"o\">+</span> <span class=\"o\">(</span><span class=\"n\">currentOperand</span> <span class=\"o\">*</span> <span class=\"n\">previousOperand</span><span class=\"o\">),</span>          <span class=\"n\">ops</span><span class=\"o\">);</span>      <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">remove</span><span class=\"o\">(</span><span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()</span> <span class=\"o\">-</span> <span class=\"mi\">1</span><span class=\"o\">);</span>      <span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">remove</span><span class=\"o\">(</span><span class=\"n\">ops</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()</span> <span class=\"o\">-</span> <span class=\"mi\">1</span><span class=\"o\">);</span>    <span class=\"o\">}</span>  <span class=\"o\">}</span>  <span class=\"kd\">public</span> <span class=\"nc\">List</span><span class=\"o\">&lt;</span><span class=\"nc\">String</span><span class=\"o\">&gt;</span> <span class=\"nf\">addOperators</span><span class=\"o\">(</span><span class=\"nc\">String</span> <span class=\"n\">num</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">target</span><span class=\"o\">)</span> <span class=\"o\">{</span>    <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">num</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">()</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"o\">)</span> <span class=\"o\">{</span>      <span class=\"k\">return</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">String</span><span class=\"o\">&gt;();</span>    <span class=\"o\">}</span>    <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">target</span> <span class=\"o\">=</span> <span class=\"n\">target</span><span class=\"o\">;</span>    <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">digits</span> <span class=\"o\">=</span> <span class=\"n\">num</span><span class=\"o\">;</span>    <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">answer</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">String</span><span class=\"o\">&gt;();</span>    <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">recurse</span><span class=\"o\">(</span><span class=\"mi\">0</span><span class=\"o\">,</span> <span class=\"mi\">0</span><span class=\"o\">,</span> <span class=\"mi\">0</span><span class=\"o\">,</span> <span class=\"mi\">0</span><span class=\"o\">,</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">String</span><span class=\"o\">&gt;());</span>    <span class=\"k\">return</span> <span class=\"k\">this</span><span class=\"o\">.</span><span class=\"na\">answer</span><span class=\"o\">;</span>  <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/19/expression-add-operators",
            
            
            
            "tags": ["leetcode","java","hard","note"],
            
            "date_published": "2021-09-19T00:00:00-05:00",
            "date_modified": "2021-09-19T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/18/arrays-intersection",
            "title": "Intersection of Two Arrays II",
            "summary": "Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order.",
            "content_text": "Problem StatementGiven a linked list of N nodes such that it may contain a loop.A loop here means that the last node of the link list is connected to the node at position X. If the link list does not have any loop, X=0.Remove the loop from the linked list, if it is present.Appris  Streams in Java take much time then simple array value insertion. arr1 method took 14ms, where as arr2 method only took 6msint[] arr1 = lst.stream().mapToInt(Integer::intValue).toArray();int arr2[] = new int[lst.size()];for(int i=0;i&lt;lst.size();i++) {    arr2[i] = lst.get(i);}Solutionclass Solution {    public int[] intersect(int[] nums1, int[] nums2) {        // Map to count frequeny of numbers        Map&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;();                for(int i:nums1){            map.put(i,map.getOrDefault(i,0)+1);        }                // Use Resizeable array, since there may n or m numbers         // of numbers in results         ArrayList&lt;Integer&gt; lst = new ArrayList&lt;&gt;();                for(int i:nums2){            // for each number in array 2, update the character             // frequency of initial map             if(map.containsKey(i)==true &amp;&amp; map.get(i)&gt;0){                lst.add(i);                map.put(i,map.get(i)-1);            }        }                // ArrayList -&gt; Array         int arr[] = new int[lst.size()];        for(int i=0;i&lt;lst.size();i++) {            arr[i] = lst.get(i);        }        return arr;    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given a linked list of N nodes such that it may contain a loop.A loop here means that the last node of the link list is connected to the node at position X. If the link list does not have any loop, X=0.Remove the loop from the linked list, if it is present.</p><h3 id=\"appris\">Appris</h3><ul>  <li>Streams in Java take much time then simple array value insertion. <code>arr1</code> method took <code>14ms</code>, where as <code>arr2</code> method only took <code>6ms</code></li></ul><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">arr1</span> <span class=\"o\">=</span> <span class=\"n\">lst</span><span class=\"o\">.</span><span class=\"na\">stream</span><span class=\"o\">().</span><span class=\"na\">mapToInt</span><span class=\"o\">(</span><span class=\"nl\">Integer:</span><span class=\"o\">:</span><span class=\"n\">intValue</span><span class=\"o\">).</span><span class=\"na\">toArray</span><span class=\"o\">();</span><span class=\"kt\">int</span> <span class=\"n\">arr2</span><span class=\"o\">[]</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">int</span><span class=\"o\">[</span><span class=\"n\">lst</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()];</span><span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">lst</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">();</span><span class=\"n\">i</span><span class=\"o\">++)</span> <span class=\"o\">{</span>    <span class=\"n\">arr2</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]</span> <span class=\"o\">=</span> <span class=\"n\">lst</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">);</span><span class=\"o\">}</span></code></pre></div></div><p><br /></p><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span> <span class=\"o\">{</span>    <span class=\"kd\">public</span> <span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"nf\">intersect</span><span class=\"o\">(</span><span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">nums1</span><span class=\"o\">,</span> <span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">nums2</span><span class=\"o\">)</span> <span class=\"o\">{</span>        <span class=\"c1\">// Map to count frequeny of numbers</span>        <span class=\"nc\">Map</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">,</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">map</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">HashMap</span><span class=\"o\">&lt;&gt;();</span>                <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"nl\">i:</span><span class=\"n\">nums1</span><span class=\"o\">){</span>            <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">,</span><span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">getOrDefault</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">,</span><span class=\"mi\">0</span><span class=\"o\">)+</span><span class=\"mi\">1</span><span class=\"o\">);</span>        <span class=\"o\">}</span>                <span class=\"c1\">// Use Resizeable array, since there may n or m numbers </span>        <span class=\"c1\">// of numbers in results </span>        <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">lst</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;&gt;();</span>                <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"nl\">i:</span><span class=\"n\">nums2</span><span class=\"o\">){</span>            <span class=\"c1\">// for each number in array 2, update the character </span>            <span class=\"c1\">// frequency of initial map </span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">containsKey</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">)==</span><span class=\"kc\">true</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">)&gt;</span><span class=\"mi\">0</span><span class=\"o\">){</span>                <span class=\"n\">lst</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">);</span>                <span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">put</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">,</span><span class=\"n\">map</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">)-</span><span class=\"mi\">1</span><span class=\"o\">);</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>                <span class=\"c1\">// ArrayList -&gt; Array </span>        <span class=\"kt\">int</span> <span class=\"n\">arr</span><span class=\"o\">[]</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">int</span><span class=\"o\">[</span><span class=\"n\">lst</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">()];</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">lst</span><span class=\"o\">.</span><span class=\"na\">size</span><span class=\"o\">();</span><span class=\"n\">i</span><span class=\"o\">++)</span> <span class=\"o\">{</span>            <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]</span> <span class=\"o\">=</span> <span class=\"n\">lst</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">);</span>        <span class=\"o\">}</span>        <span class=\"k\">return</span> <span class=\"n\">arr</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/18/arrays-intersection",
            
            
            
            "tags": ["leetcode","easy"],
            
            "date_published": "2021-09-18T00:00:00-05:00",
            "date_modified": "2021-09-18T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/18/sum-of-query-ii",
            "title": "Sum of Query II",
            "summary": "You are given an array arr[] of n integers and q queries in an array queries[] of length 2*q containing l, r pair for all q queries. You need to compute the following sum over q queries.",
            "content_text": "Problem StatementYou are given an array arr[] of n integers and q queries in an array queries[] of length 2*q containing l, r pair for all q queries. You need to compute the following sum over q queries.Example  Need to find the sum of numbers between two points          why not find complete sum and remove                  the staring and          the ending sum                    starting and ending sum can be found out in O(n)      Solutionclass Solution{    List&lt;Integer&gt; querySum(int n, int arr[], int q, int queries[])    {        // code here        // find prefix_sum and suffix_sum        int[] preSum = new int[n+1];        int[] sufSum = new int[n+1];                preSum[0] = 0;        sufSum[n] = 0;        int t = 0;        for(int i=0;i&lt;n;i++){            preSum[i+1]=arr[i]+preSum[i];            t+=arr[i];        }                for(int i=n-1;i&gt;=0;i--){            sufSum[i]=arr[i]+sufSum[i+1];        }                List&lt;Integer&gt; res = new ArrayList&lt;&gt;();                for(int i=0;i&lt;2*q;i+=2){            res.add(t-preSum[queries[i]-1]-sufSum[queries[i+1]]);        }                return res;    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>You are given an array arr[] of n integers and q queries in an array queries[] of length 2*q containing l, r pair for all q queries. You need to compute the following sum over q queries.</p><h2 id=\"example\">Example</h2><ul>  <li>Need to find the sum of numbers between two points    <ul>      <li>why not find complete sum and remove        <ul>          <li>the staring and</li>          <li>the ending sum</li>        </ul>      </li>      <li>starting and ending sum can be found out in <code>O(n)<code></code></code></li>    </ul>  </li></ul><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"nc\">List</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"nf\">querySum</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">arr</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">q</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">queries</span><span class=\"o\">[])</span>    <span class=\"o\">{</span>        <span class=\"c1\">// code here</span>        <span class=\"c1\">// find prefix_sum and suffix_sum</span>        <span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">preSum</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">int</span><span class=\"o\">[</span><span class=\"n\">n</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">];</span>        <span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">sufSum</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"kt\">int</span><span class=\"o\">[</span><span class=\"n\">n</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">];</span>                <span class=\"n\">preSum</span><span class=\"o\">[</span><span class=\"mi\">0</span><span class=\"o\">]</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"n\">sufSum</span><span class=\"o\">[</span><span class=\"n\">n</span><span class=\"o\">]</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">n</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"n\">preSum</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">]=</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]+</span><span class=\"n\">preSum</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">];</span>            <span class=\"n\">t</span><span class=\"o\">+=</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">];</span>        <span class=\"o\">}</span>                <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"n\">n</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&gt;=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">--){</span>            <span class=\"n\">sufSum</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]=</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]+</span><span class=\"n\">sufSum</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">];</span>        <span class=\"o\">}</span>                <span class=\"nc\">List</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;&gt;();</span>                <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"mi\">2</span><span class=\"o\">*</span><span class=\"n\">q</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">+=</span><span class=\"mi\">2</span><span class=\"o\">){</span>            <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">t</span><span class=\"o\">-</span><span class=\"n\">preSum</span><span class=\"o\">[</span><span class=\"n\">queries</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]-</span><span class=\"mi\">1</span><span class=\"o\">]-</span><span class=\"n\">sufSum</span><span class=\"o\">[</span><span class=\"n\">queries</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"o\">]]);</span>        <span class=\"o\">}</span>                <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/18/sum-of-query-ii",
            
            
            
            "tags": ["gfg","medium","potd"],
            
            "date_published": "2021-09-18T00:00:00-05:00",
            "date_modified": "2021-09-18T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/17/spiral-order-in-matrix",
            "title": "Spiral order in matrix.",
            "summary": "Given an m x n matrix, return all elements of the matrix in spiral order.",
            "content_text": "Problem StatementGiven an m x n matrix, return all elements of the matrix in spiral order.Edge Cases  Even and Odd Number of Rows and Columns[[1,2,3],[4,5,6],[7,8,9],[7,8,9]][[1,2,3,4],[5,6,7,8],[9,10,11,12],[9,10,11,12]]SolutionCode:class Solution {    public List&lt;Integer&gt; spiralOrder(int[][] matrix) {        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();                int n = matrix.length;        int m = matrix[0].length;                int x0 =0,x1=m-1;        int y0=0,y1=n-1;                        while(x0&lt;=x1 &amp;&amp; y0&lt;=y1){                        for(int i=x0;i&lt;=x1;i++){                res.add(matrix[y0][i]);            }            y0++;                        for(int j=y0;j&lt;=y1;j++){                res.add(matrix[j][x1]);            }            x1--;                        if(y0&lt;=y1){                for(int i=x1;i&gt;=x0;i--){                    res.add(matrix[y1][i]);                }            }            y1--;            if(x0&lt;=x1){                for(int j=y1;j&gt;=y0;j--){                    res.add(matrix[j][x0]);                }            }            x0++;        }        return res;    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given an m x n matrix, return all elements of the matrix in spiral order.</p><h3 id=\"edge-cases\">Edge Cases</h3><ul>  <li>Even and Odd Number of Rows and Columns</li></ul><div class=\"language-text highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>[[1,2,3],[4,5,6],[7,8,9],[7,8,9]][[1,2,3,4],[5,6,7,8],[9,10,11,12],[9,10,11,12]]</code></pre></div></div><h3 id=\"solution\">Solution</h3><p>Code:</p><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span> <span class=\"o\">{</span>    <span class=\"kd\">public</span> <span class=\"nc\">List</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"nf\">spiralOrder</span><span class=\"o\">(</span><span class=\"kt\">int</span><span class=\"o\">[][]</span> <span class=\"n\">matrix</span><span class=\"o\">)</span> <span class=\"o\">{</span>        <span class=\"nc\">List</span><span class=\"o\">&lt;</span><span class=\"nc\">Integer</span><span class=\"o\">&gt;</span> <span class=\"n\">res</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;&gt;();</span>                <span class=\"kt\">int</span> <span class=\"n\">n</span> <span class=\"o\">=</span> <span class=\"n\">matrix</span><span class=\"o\">.</span><span class=\"na\">length</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">m</span> <span class=\"o\">=</span> <span class=\"n\">matrix</span><span class=\"o\">[</span><span class=\"mi\">0</span><span class=\"o\">].</span><span class=\"na\">length</span><span class=\"o\">;</span>                <span class=\"kt\">int</span> <span class=\"n\">x0</span> <span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">,</span><span class=\"n\">x1</span><span class=\"o\">=</span><span class=\"n\">m</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">y0</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">,</span><span class=\"n\">y1</span><span class=\"o\">=</span><span class=\"n\">n</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">;</span>                        <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">x0</span><span class=\"o\">&lt;=</span><span class=\"n\">x1</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">y0</span><span class=\"o\">&lt;=</span><span class=\"n\">y1</span><span class=\"o\">){</span>                        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"n\">x0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;=</span><span class=\"n\">x1</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>                <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">matrix</span><span class=\"o\">[</span><span class=\"n\">y0</span><span class=\"o\">][</span><span class=\"n\">i</span><span class=\"o\">]);</span>            <span class=\"o\">}</span>            <span class=\"n\">y0</span><span class=\"o\">++;</span>                        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">j</span><span class=\"o\">=</span><span class=\"n\">y0</span><span class=\"o\">;</span><span class=\"n\">j</span><span class=\"o\">&lt;=</span><span class=\"n\">y1</span><span class=\"o\">;</span><span class=\"n\">j</span><span class=\"o\">++){</span>                <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">matrix</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">][</span><span class=\"n\">x1</span><span class=\"o\">]);</span>            <span class=\"o\">}</span>            <span class=\"n\">x1</span><span class=\"o\">--;</span>                        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">y0</span><span class=\"o\">&lt;=</span><span class=\"n\">y1</span><span class=\"o\">){</span>                <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"n\">x1</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&gt;=</span><span class=\"n\">x0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">--){</span>                    <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">matrix</span><span class=\"o\">[</span><span class=\"n\">y1</span><span class=\"o\">][</span><span class=\"n\">i</span><span class=\"o\">]);</span>                <span class=\"o\">}</span>            <span class=\"o\">}</span>            <span class=\"n\">y1</span><span class=\"o\">--;</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">x0</span><span class=\"o\">&lt;=</span><span class=\"n\">x1</span><span class=\"o\">){</span>                <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">j</span><span class=\"o\">=</span><span class=\"n\">y1</span><span class=\"o\">;</span><span class=\"n\">j</span><span class=\"o\">&gt;=</span><span class=\"n\">y0</span><span class=\"o\">;</span><span class=\"n\">j</span><span class=\"o\">--){</span>                    <span class=\"n\">res</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"n\">matrix</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">][</span><span class=\"n\">x0</span><span class=\"o\">]);</span>                <span class=\"o\">}</span>            <span class=\"o\">}</span>            <span class=\"n\">x0</span><span class=\"o\">++;</span>        <span class=\"o\">}</span>        <span class=\"k\">return</span> <span class=\"n\">res</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/17/spiral-order-in-matrix",
            
            
            
            "tags": ["leetcode","java"],
            
            "date_published": "2021-09-17T00:00:00-05:00",
            "date_modified": "2021-09-17T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/17/kth-element-of-two-sorted-arrays",
            "title": "K-th element of two sorted Arrays",
            "summary": "Given two sorted arrays arr1 and arr2 of size N and M respectively and an element K. The task is to find the element that would be at the k’th position of the final sorted array.",
            "content_text": "Problem StatementGiven two sorted arrays arr1 and arr2 of size N and M respectively and an element K. The task is to find the element that would be at the k’th position of the final sorted array.Edge Cases  What if arrays are sorted and given.5 7 672 86 100 112 113119 256 265 349 445 770 892SolutionCode:class Solution {    public long kthElement( int arr1[], int arr2[], int n, int m, int k) {        int a1 = 0;        int a2 = 0;        boolean flag = true;                for(int i=0;i&lt;k;i++){            if(a1&gt;=n){                flag = false;                a2++;            }else if (a2&gt;=m){                flag = true;                a1++;            }else{                if(arr1[a1]&lt;=arr2[a2]){                    flag=true;                    a1++;                }else{                    flag=false;                    a2++;                }            }        }        if(flag){            return  arr1[a1-1];        }else{            return arr2[a2-1];        }    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given two sorted arrays arr1 and arr2 of size N and M respectively and an element K. The task is to find the element that would be at the k’th position of the final sorted array.</p><h3 id=\"edge-cases\">Edge Cases</h3><ul>  <li>What if arrays are sorted and given.</li></ul><div class=\"language-text highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>5 7 672 86 100 112 113119 256 265 349 445 770 892</code></pre></div></div><h3 id=\"solution\">Solution</h3><p>Code:</p><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span> <span class=\"o\">{</span>    <span class=\"kd\">public</span> <span class=\"kt\">long</span> <span class=\"nf\">kthElement</span><span class=\"o\">(</span> <span class=\"kt\">int</span> <span class=\"n\">arr1</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">arr2</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">m</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">k</span><span class=\"o\">)</span> <span class=\"o\">{</span>        <span class=\"kt\">int</span> <span class=\"n\">a1</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">a2</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"kt\">boolean</span> <span class=\"n\">flag</span> <span class=\"o\">=</span> <span class=\"kc\">true</span><span class=\"o\">;</span>                <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">k</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">a1</span><span class=\"o\">&gt;=</span><span class=\"n\">n</span><span class=\"o\">){</span>                <span class=\"n\">flag</span> <span class=\"o\">=</span> <span class=\"kc\">false</span><span class=\"o\">;</span>                <span class=\"n\">a2</span><span class=\"o\">++;</span>            <span class=\"o\">}</span><span class=\"k\">else</span> <span class=\"k\">if</span> <span class=\"o\">(</span><span class=\"n\">a2</span><span class=\"o\">&gt;=</span><span class=\"n\">m</span><span class=\"o\">){</span>                <span class=\"n\">flag</span> <span class=\"o\">=</span> <span class=\"kc\">true</span><span class=\"o\">;</span>                <span class=\"n\">a1</span><span class=\"o\">++;</span>            <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>                <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">arr1</span><span class=\"o\">[</span><span class=\"n\">a1</span><span class=\"o\">]&lt;=</span><span class=\"n\">arr2</span><span class=\"o\">[</span><span class=\"n\">a2</span><span class=\"o\">]){</span>                    <span class=\"n\">flag</span><span class=\"o\">=</span><span class=\"kc\">true</span><span class=\"o\">;</span>                    <span class=\"n\">a1</span><span class=\"o\">++;</span>                <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>                    <span class=\"n\">flag</span><span class=\"o\">=</span><span class=\"kc\">false</span><span class=\"o\">;</span>                    <span class=\"n\">a2</span><span class=\"o\">++;</span>                <span class=\"o\">}</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">flag</span><span class=\"o\">){</span>            <span class=\"k\">return</span>  <span class=\"n\">arr1</span><span class=\"o\">[</span><span class=\"n\">a1</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">];</span>        <span class=\"o\">}</span><span class=\"k\">else</span><span class=\"o\">{</span>            <span class=\"k\">return</span> <span class=\"n\">arr2</span><span class=\"o\">[</span><span class=\"n\">a2</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">];</span>        <span class=\"o\">}</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/17/kth-element-of-two-sorted-arrays",
            
            
            
            "tags": ["gfg","potd","java"],
            
            "date_published": "2021-09-17T00:00:00-05:00",
            "date_modified": "2021-09-17T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/16/n-meetings-in-one-room",
            "title": "N meetings in one room",
            "summary": "Given an array A[] consisting 0s, 1s and 2s. The task is to write a function that sorts the given array. The functions should put all 0s first, then all 1s and all 2s in last.",
            "content_text": "Problem StatementThere is one meeting room in a firm. There are N meetings in the form of (start[i], end[i]) where start[i] is start time of meeting i and end[i] is finish time of meeting i.What is the maximum number of meetings that can be accommodated in the meeting room when only one meeting can be held in the meeting room at a particular time?Solutionclass Solution {    //Function to find the maximum number of meetings that can    //be performed in a meeting room.    public static int maxMeetings(int start[], int end[], int n)    {        // add your code here        ArrayList&lt;Meet&gt; schd = new ArrayList&lt;&gt;();        for(int i=0;i&lt;n;i++){            schd.add(new Meet(start[i],end[i]));        }        Collections.sort(schd,(Meet m1, Meet m2) -&gt; {            if(m1.e==m2.e){                return m2.s-m1.s;            }            return m1.e-m2.e;        });                int cnt = 0;        // System.out.println(schd);        int l = Integer.MIN_VALUE;        for(int i=0;i&lt;n;i++){            if(schd.get(i).s&gt;l){                l = schd.get(i).e;                cnt++;            }        }        return cnt;    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>There is one meeting room in a firm. There are N meetings in the form of (start[i], end[i]) where start[i] is start time of meeting i and end[i] is finish time of meeting i.What is the maximum number of meetings that can be accommodated in the meeting room when only one meeting can be held in the meeting room at a particular time?</p><h3 id=\"solution\">Solution</h3><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span> <span class=\"o\">{</span>    <span class=\"c1\">//Function to find the maximum number of meetings that can</span>    <span class=\"c1\">//be performed in a meeting room.</span>    <span class=\"kd\">public</span> <span class=\"kd\">static</span> <span class=\"kt\">int</span> <span class=\"nf\">maxMeetings</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">start</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">end</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">)</span>    <span class=\"o\">{</span>        <span class=\"c1\">// add your code here</span>        <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;</span><span class=\"nc\">Meet</span><span class=\"o\">&gt;</span> <span class=\"n\">schd</span> <span class=\"o\">=</span> <span class=\"k\">new</span> <span class=\"nc\">ArrayList</span><span class=\"o\">&lt;&gt;();</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">n</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"n\">schd</span><span class=\"o\">.</span><span class=\"na\">add</span><span class=\"o\">(</span><span class=\"k\">new</span> <span class=\"nc\">Meet</span><span class=\"o\">(</span><span class=\"n\">start</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">],</span><span class=\"n\">end</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]));</span>        <span class=\"o\">}</span>        <span class=\"nc\">Collections</span><span class=\"o\">.</span><span class=\"na\">sort</span><span class=\"o\">(</span><span class=\"n\">schd</span><span class=\"o\">,(</span><span class=\"nc\">Meet</span> <span class=\"n\">m1</span><span class=\"o\">,</span> <span class=\"nc\">Meet</span> <span class=\"n\">m2</span><span class=\"o\">)</span> <span class=\"o\">-&gt;</span> <span class=\"o\">{</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">m1</span><span class=\"o\">.</span><span class=\"na\">e</span><span class=\"o\">==</span><span class=\"n\">m2</span><span class=\"o\">.</span><span class=\"na\">e</span><span class=\"o\">){</span>                <span class=\"k\">return</span> <span class=\"n\">m2</span><span class=\"o\">.</span><span class=\"na\">s</span><span class=\"o\">-</span><span class=\"n\">m1</span><span class=\"o\">.</span><span class=\"na\">s</span><span class=\"o\">;</span>            <span class=\"o\">}</span>            <span class=\"k\">return</span> <span class=\"n\">m1</span><span class=\"o\">.</span><span class=\"na\">e</span><span class=\"o\">-</span><span class=\"n\">m2</span><span class=\"o\">.</span><span class=\"na\">e</span><span class=\"o\">;</span>        <span class=\"o\">});</span>                <span class=\"kt\">int</span> <span class=\"n\">cnt</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"c1\">// System.out.println(schd);</span>        <span class=\"kt\">int</span> <span class=\"n\">l</span> <span class=\"o\">=</span> <span class=\"nc\">Integer</span><span class=\"o\">.</span><span class=\"na\">MIN_VALUE</span><span class=\"o\">;</span>        <span class=\"k\">for</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">&lt;</span><span class=\"n\">n</span><span class=\"o\">;</span><span class=\"n\">i</span><span class=\"o\">++){</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">schd</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">).</span><span class=\"na\">s</span><span class=\"o\">&gt;</span><span class=\"n\">l</span><span class=\"o\">){</span>                <span class=\"n\">l</span> <span class=\"o\">=</span> <span class=\"n\">schd</span><span class=\"o\">.</span><span class=\"na\">get</span><span class=\"o\">(</span><span class=\"n\">i</span><span class=\"o\">).</span><span class=\"na\">e</span><span class=\"o\">;</span>                <span class=\"n\">cnt</span><span class=\"o\">++;</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>        <span class=\"k\">return</span> <span class=\"n\">cnt</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/16/n-meetings-in-one-room",
            
            
            
            "tags": ["gfg","potd","java"],
            
            "date_published": "2021-09-16T00:00:00-05:00",
            "date_modified": "2021-09-16T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/15/sort-an-array-of-0s-1s-and-2s",
            "title": "Sort an array of 0s, 1s and 2s",
            "summary": "Given an array A[] consisting 0s, 1s and 2s. The task is to write a function that sorts the given array. The functions should put all 0s first, then all 1s and all 2s in last.",
            "content_text": "Problem StatementGiven an array A[] consisting 0s, 1s and 2s. The task is to write a function that sorts the given array. The functions should put all 0s first, then all 1s and all 2s in last.TriviaThis is called as Dutch National Flag AlgorithmSolutionCode:class Solution{    public static void sort012(int a[], int n)    {        // code here         int l =0;        int m =0;        int f = n-1;        while(m&lt;=f){            if(a[m]==0){                swap(a,m,l);                m++;                l++;            }else if(a[m]==1){                m++;            }else if(a[m]==2){                swap(a,m,f);                f--;            }        }    }    private static void swap(int[] arr, int i, int j){        //3      1        2        arr[i]=arr[i]+arr[j];        //1     3        2        arr[j]=arr[i]-arr[j];        //2     3        1        arr[i]=arr[i]-arr[j];    }}",
            "content_html": "<h3 id=\"problem-statement\">Problem Statement</h3><p>Given an array A[] consisting 0s, 1s and 2s. The task is to write a function that sorts the given array. The functions should put all 0s first, then all 1s and all 2s in last.</p><h2 id=\"trivia\">Trivia</h2><p>This is called as Dutch National Flag Algorithm</p><h3 id=\"solution\">Solution</h3><p>Code:</p><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"kd\">public</span> <span class=\"kd\">static</span> <span class=\"kt\">void</span> <span class=\"nf\">sort012</span><span class=\"o\">(</span><span class=\"kt\">int</span> <span class=\"n\">a</span><span class=\"o\">[],</span> <span class=\"kt\">int</span> <span class=\"n\">n</span><span class=\"o\">)</span>    <span class=\"o\">{</span>        <span class=\"c1\">// code here </span>        <span class=\"kt\">int</span> <span class=\"n\">l</span> <span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">m</span> <span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"o\">;</span>        <span class=\"kt\">int</span> <span class=\"n\">f</span> <span class=\"o\">=</span> <span class=\"n\">n</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"o\">;</span>        <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">m</span><span class=\"o\">&lt;=</span><span class=\"n\">f</span><span class=\"o\">){</span>            <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">a</span><span class=\"o\">[</span><span class=\"n\">m</span><span class=\"o\">]==</span><span class=\"mi\">0</span><span class=\"o\">){</span>                <span class=\"n\">swap</span><span class=\"o\">(</span><span class=\"n\">a</span><span class=\"o\">,</span><span class=\"n\">m</span><span class=\"o\">,</span><span class=\"n\">l</span><span class=\"o\">);</span>                <span class=\"n\">m</span><span class=\"o\">++;</span>                <span class=\"n\">l</span><span class=\"o\">++;</span>            <span class=\"o\">}</span><span class=\"k\">else</span> <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">a</span><span class=\"o\">[</span><span class=\"n\">m</span><span class=\"o\">]==</span><span class=\"mi\">1</span><span class=\"o\">){</span>                <span class=\"n\">m</span><span class=\"o\">++;</span>            <span class=\"o\">}</span><span class=\"k\">else</span> <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">a</span><span class=\"o\">[</span><span class=\"n\">m</span><span class=\"o\">]==</span><span class=\"mi\">2</span><span class=\"o\">){</span>                <span class=\"n\">swap</span><span class=\"o\">(</span><span class=\"n\">a</span><span class=\"o\">,</span><span class=\"n\">m</span><span class=\"o\">,</span><span class=\"n\">f</span><span class=\"o\">);</span>                <span class=\"n\">f</span><span class=\"o\">--;</span>            <span class=\"o\">}</span>        <span class=\"o\">}</span>    <span class=\"o\">}</span>    <span class=\"kd\">private</span> <span class=\"kd\">static</span> <span class=\"kt\">void</span> <span class=\"nf\">swap</span><span class=\"o\">(</span><span class=\"kt\">int</span><span class=\"o\">[]</span> <span class=\"n\">arr</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">i</span><span class=\"o\">,</span> <span class=\"kt\">int</span> <span class=\"n\">j</span><span class=\"o\">){</span>        <span class=\"c1\">//3      1        2</span>        <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]=</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]+</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">];</span>        <span class=\"c1\">//1     3        2</span>        <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">]=</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]-</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">];</span>        <span class=\"c1\">//2     3        1</span>        <span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]=</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">i</span><span class=\"o\">]-</span><span class=\"n\">arr</span><span class=\"o\">[</span><span class=\"n\">j</span><span class=\"o\">];</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/15/sort-an-array-of-0s-1s-and-2s",
            
            
            
            "tags": ["gfg","potd","java"],
            
            "date_published": "2021-09-15T00:00:00-05:00",
            "date_modified": "2021-09-15T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        },
    
        {
            "id": "https://swarag-n.github.io/Schatz/2021/09/14/remove-loop-in-linkedlist",
            "title": "Remove loop in Linked List",
            "summary": "This is a collection of short CSS snippets I thought might be useful for beginners",
            "content_text": "Problem StatementGiven a linked list of N nodes such that it may contain a loop.A loop here means that the last node of the link list is connected to the node at position X. If the link list does not have any loop, X=0.Remove the loop from the linked list, if it is present.Edge Cases  Even Length Circular Linkedlist.41 2 3 41SolutionCode:class Solution{    //Function to remove a loop in the linked list.    public static void removeLoop(Node head){        // code here        // remove the loop without losing any nodes        if(head==null || head.next==null){            return;        }        Node fast = head;        Node slow = head;        Node prev = head;        do{            fast = fast.next.next;            prev = slow;            slow = slow.next;        }while(slow != fast &amp;&amp; fast!=null &amp;&amp; fast.next!=null);                // check if no loop        if(fast==null || fast.next == null){            return;        }                if(prev.next==head){            prev.next=null;            return;        }        // even length Circular Linked List Edge Case        fast = head;        Node temp=null;        while(fast!=slow){            fast=fast.next;            temp = slow;            slow=slow.next;        }        temp.next = null;        return;    }}",
            "content_html": "<h2 id=\"problem-statement\">Problem Statement</h2><p>Given a linked list of N nodes such that it may contain a loop.A loop here means that the last node of the link list is connected to the node at position X. If the link list does not have any loop, X=0.Remove the loop from the linked list, if it is present.</p><h3 id=\"edge-cases\">Edge Cases</h3><ul>  <li>Even Length Circular Linkedlist.</li></ul><div class=\"language-text highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code>41 2 3 41</code></pre></div></div><h2 id=\"solution\">Solution</h2><p>Code:</p><div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kd\">class</span> <span class=\"nc\">Solution</span><span class=\"o\">{</span>    <span class=\"c1\">//Function to remove a loop in the linked list.</span>    <span class=\"kd\">public</span> <span class=\"kd\">static</span> <span class=\"kt\">void</span> <span class=\"nf\">removeLoop</span><span class=\"o\">(</span><span class=\"nc\">Node</span> <span class=\"n\">head</span><span class=\"o\">){</span>        <span class=\"c1\">// code here</span>        <span class=\"c1\">// remove the loop without losing any nodes</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">head</span><span class=\"o\">==</span><span class=\"kc\">null</span> <span class=\"o\">||</span> <span class=\"n\">head</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">==</span><span class=\"kc\">null</span><span class=\"o\">){</span>            <span class=\"k\">return</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"nc\">Node</span> <span class=\"n\">fast</span> <span class=\"o\">=</span> <span class=\"n\">head</span><span class=\"o\">;</span>        <span class=\"nc\">Node</span> <span class=\"n\">slow</span> <span class=\"o\">=</span> <span class=\"n\">head</span><span class=\"o\">;</span>        <span class=\"nc\">Node</span> <span class=\"n\">prev</span> <span class=\"o\">=</span> <span class=\"n\">head</span><span class=\"o\">;</span>        <span class=\"k\">do</span><span class=\"o\">{</span>            <span class=\"n\">fast</span> <span class=\"o\">=</span> <span class=\"n\">fast</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">;</span>            <span class=\"n\">prev</span> <span class=\"o\">=</span> <span class=\"n\">slow</span><span class=\"o\">;</span>            <span class=\"n\">slow</span> <span class=\"o\">=</span> <span class=\"n\">slow</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">;</span>        <span class=\"o\">}</span><span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">slow</span> <span class=\"o\">!=</span> <span class=\"n\">fast</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">fast</span><span class=\"o\">!=</span><span class=\"kc\">null</span> <span class=\"o\">&amp;&amp;</span> <span class=\"n\">fast</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">!=</span><span class=\"kc\">null</span><span class=\"o\">);</span>                <span class=\"c1\">// check if no loop</span>        <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">fast</span><span class=\"o\">==</span><span class=\"kc\">null</span> <span class=\"o\">||</span> <span class=\"n\">fast</span><span class=\"o\">.</span><span class=\"na\">next</span> <span class=\"o\">==</span> <span class=\"kc\">null</span><span class=\"o\">){</span>            <span class=\"k\">return</span><span class=\"o\">;</span>        <span class=\"o\">}</span>                <span class=\"k\">if</span><span class=\"o\">(</span><span class=\"n\">prev</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">==</span><span class=\"n\">head</span><span class=\"o\">){</span>            <span class=\"n\">prev</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">=</span><span class=\"kc\">null</span><span class=\"o\">;</span>            <span class=\"k\">return</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"c1\">// even length Circular Linked List Edge Case</span>        <span class=\"n\">fast</span> <span class=\"o\">=</span> <span class=\"n\">head</span><span class=\"o\">;</span>        <span class=\"nc\">Node</span> <span class=\"n\">temp</span><span class=\"o\">=</span><span class=\"kc\">null</span><span class=\"o\">;</span>        <span class=\"k\">while</span><span class=\"o\">(</span><span class=\"n\">fast</span><span class=\"o\">!=</span><span class=\"n\">slow</span><span class=\"o\">){</span>            <span class=\"n\">fast</span><span class=\"o\">=</span><span class=\"n\">fast</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">;</span>            <span class=\"n\">temp</span> <span class=\"o\">=</span> <span class=\"n\">slow</span><span class=\"o\">;</span>            <span class=\"n\">slow</span><span class=\"o\">=</span><span class=\"n\">slow</span><span class=\"o\">.</span><span class=\"na\">next</span><span class=\"o\">;</span>        <span class=\"o\">}</span>        <span class=\"n\">temp</span><span class=\"o\">.</span><span class=\"na\">next</span> <span class=\"o\">=</span> <span class=\"kc\">null</span><span class=\"o\">;</span>        <span class=\"k\">return</span><span class=\"o\">;</span>    <span class=\"o\">}</span><span class=\"o\">}</span></code></pre></div></div>",
            "url": "https://swarag-n.github.io/Schatz/2021/09/14/remove-loop-in-linkedlist",
            
            
            
            "tags": ["gfg","potd","java","edge_case"],
            
            "date_published": "2021-09-14T00:00:00-05:00",
            "date_modified": "2021-09-14T00:00:00-05:00",
            
                "author":  {
                "name": "Swarag Narayanasetty",
                "url": null,
                "avatar": null
                }
                
            
        }
    
    ]
}