Given a permutation **P** of first **N** natural numbers. The task is to find the number of **i’s** such that **P _{i} ≤ P_{j}** for all

**1 ≤ j ≤ i**in the permutation of first

**N**natural numbers.

**Examples:**

Input:arr[] = {4, 2, 5, 1, 3}Output:3

0, 1 and 3 are such indices.Input:arr[] = {4, 3, 2, 1}Output:4

**Approach:** For **i = 1, …, N**, define** M _{i} = min{ P_{j}, 1 ≤ j ≤ i}**. Now, when

**i(1 ≤ i ≤ N)**is fixed,

**M**holds if and only if for all

_{i}= P_{i}**j(1 ≤ j ≤ i), P**holds. Therefore, it is enough to calculate all the

_{i}≤ P_{j}**M**. These can be calculated in the increasing order of

_{i}**i**, so the problem could be solved in a total of

**O(N)**time.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the number of i's` `// such that Pi <= Pj for all 1 <= j <= i` `// in the permutation of first N natural numbers` `int` `min_index(` `int` `p[], ` `int` `n)` `{` ` ` `// To store the count of such indices` ` ` `int` `ans = 0;` ` ` `// Store the mini value` ` ` `int` `mini = INT_MAX;` ` ` `// For all the elements` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `if` `(p[i] <= mini)` ` ` `mini = p[i];` ` ` `if` `(mini == p[i])` ` ` `ans++;` ` ` `}` ` ` `// Return the required answer` ` ` `return` `ans;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `P[] = { 4, 2, 5, 1, 3 };` ` ` `int` `n = ` `sizeof` `(P) / ` `sizeof` `(` `int` `);` ` ` `cout << min_index(P, n);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` ` ` `static` `int` `INT_MAX = Integer.MAX_VALUE;` ` ` ` ` `// Function to return the number of i's` ` ` `// such that Pi <= Pj for all 1 <= j <= i` ` ` `// in the permutation of first N natural numbers` ` ` `static` `int` `min_index(` `int` `p[], ` `int` `n)` ` ` `{` ` ` ` ` `// To store the count of such indices` ` ` `int` `ans = ` `0` `;` ` ` ` ` `// Store the mini value` ` ` `int` `mini = INT_MAX;` ` ` ` ` `// For all the elements` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `if` `(p[i] <= mini)` ` ` `mini = p[i];` ` ` ` ` `if` `(mini == p[i])` ` ` `ans++;` ` ` `}` ` ` ` ` `// Return the required answer` ` ` `return` `ans;` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `int` `P[] = { ` `4` `, ` `2` `, ` `5` `, ` `1` `, ` `3` `};` ` ` `int` `n = P.length;` ` ` ` ` `System.out.println(min_index(P, n));` ` ` `}` `}` `// This code is contributed by AnkitRai01` |

## Python3

`# Python3 implementation of the approach` `import` `sys` `INT_MAX ` `=` `sys.maxsize` `# Function to return the number of i's` `# such that Pi <= Pj for all 1 <= j <= i` `# in the permutation of first N natural numbers` `def` `min_index(p, n) :` ` ` `# To store the count of such indices` ` ` `ans ` `=` `0` `;` ` ` `# Store the mini value` ` ` `mini ` `=` `INT_MAX;` ` ` `# For all the elements` ` ` `for` `i ` `in` `range` `(n) :` ` ` `if` `(p[i] <` `=` `mini) :` ` ` `mini ` `=` `p[i];` ` ` `if` `(mini ` `=` `=` `p[i]) :` ` ` `ans ` `+` `=` `1` `;` ` ` `# Return the required answer` ` ` `return` `ans;` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `P ` `=` `[ ` `4` `, ` `2` `, ` `5` `, ` `1` `, ` `3` `];` ` ` `n ` `=` `len` `(P);` ` ` `print` `(min_index(P, n));` `# This code is contributed by AnkitRai01` |

## C#

`// C# implementation of the approach` `using` `System;` `class` `GFG` `{` ` ` `static` `int` `INT_MAX = ` `int` `.MaxValue;` ` ` ` ` `// Function to return the number of i's` ` ` `// such that Pi <= Pj for all 1 <= j <= i` ` ` `// in the permutation of first N natural numbers` ` ` `static` `int` `min_index(` `int` `[]p, ` `int` `n)` ` ` `{` ` ` ` ` `// To store the count of such indices` ` ` `int` `ans = 0;` ` ` ` ` `// Store the mini value` ` ` `int` `mini = INT_MAX;` ` ` ` ` `// For all the elements` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `if` `(p[i] <= mini)` ` ` `mini = p[i];` ` ` ` ` `if` `(mini == p[i])` ` ` `ans++;` ` ` `}` ` ` ` ` `// Return the required answer` ` ` `return` `ans;` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `Main ()` ` ` `{` ` ` `int` `[]P = { 4, 2, 5, 1, 3 };` ` ` `int` `n = P.Length;` ` ` ` ` `Console.WriteLine(min_index(P, n));` ` ` `}` `}` `// This code is contributed by AnkitRai01` |

## Javascript

`<script>` `// JavaScript implementation of the approach` `// Function to return the number of i's` `// such that Pi <= Pj for all 1 <= j <= i` `// in the permutation of first N natural numbers` `function` `min_index(p, n)` `{` ` ` `// To store the count of such indices` ` ` `let ans = 0;` ` ` `// Store the mini value` ` ` `let mini = Number.MAX_SAFE_INTEGER;` ` ` `// For all the elements` ` ` `for` `(let i = 0; i < n; i++) {` ` ` `if` `(p[i] <= mini)` ` ` `mini = p[i];` ` ` `if` `(mini == p[i])` ` ` `ans++;` ` ` `}` ` ` `// Return the required answer` ` ` `return` `ans;` `}` `// Driver code` ` ` `let P = [ 4, 2, 5, 1, 3 ];` ` ` `let n = P.length;` ` ` `document.write(min_index(P, n));` `// This code is contributed by Manoj.` `</script>` |

**Output:**

3

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live**