Dada una array arr[] , la tarea es encontrar el recuento de elementos de la array que satisfagan las siguientes condiciones:
- Los elementos de la array deben ser estrictamente mayores que todos los elementos de la array anteriores.
- O es el último elemento de la array o el entero debe ser estrictamente mayor que el siguiente elemento de la array.
Nota: También se puede considerar el primer entero de la array.
Ejemplos:
Entrada: arr[] = {1, 2, 0, 7, 2, 0, 2, 0}
Salida: 2
Explicación: arr[1] (= 2) y arr[3] (= 7) son los elementos del arreglo que satisfacen la condición dada.Entrada: arr[] = {4, 8, 15, 16, 23, 42}
Salida: 1
Enfoque: la idea es recorrer linealmente la array y verificar cada elemento de la array, si cumple o no la condición dada. Siga los pasos a continuación para resolver este problema:
- Atraviesa la array .
- Comenzando desde el primer elemento de la array, realice un seguimiento del elemento de array máximo encontrado hasta el momento.
- Actualice el elemento de array máximo si es mayor que el elemento de array máximo encontrado anteriormente.
- Después de actualizar el máximo actual, verifique si el siguiente elemento de la array es mayor que el elemento de la array actual o no. Si se encuentra que es cierto, incremente el conteo.
- Repita este proceso hasta que se atraviese el último elemento de la array.
- Finalmente, imprima el conteo obtenido.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to count array elements
// satisfying the given condition
int numberOfIntegers(int arr[], int N)
{
int cur_max = 0, count = 0;
// If there is only one
// array element
if (N == 1) {
count = 1;
}
else {
// Traverse the array
for (int i = 0; i < N - 1; i++) {
// Update the maximum element
// encountered so far
if (arr[i] > cur_max) {
cur_max = arr[i];
// Count the number of array elements
// strictly greater than all previous
// and immediately next elements
if (arr[i] > arr[i + 1]) {
count++;
}
}
}
if (arr[N - 1] > cur_max)
count++;
}
// Print the count
cout << count;
}
// Driver Code
int main()
{
// Given array
int arr[] = { 1, 2, 0, 7, 2, 0, 2, 0 };
// Size of the array
int N = sizeof(arr) / sizeof(arr[0]);
numberOfIntegers(arr, N);
return 0;
}
Java
// Java program for the above approach
import java.io.*;
class GFG {
// Function to count array elements
// satisfying the given condition
static void numberOfIntegers(int[] arr, int N)
{
int cur_max = 0, count = 0;
// If there is only one
// array element
if (N == 1) {
count = 1;
}
else
{
// Traverse the array
for (int i = 0; i < N - 1; i++)
{
// Update the maximum element
// encountered so far
if (arr[i] > cur_max)
{
cur_max = arr[i];
// Count the number of array elements
// strictly greater than all previous
// and immediately next elements
if (arr[i] > arr[i + 1])
{
count++;
}
}
}
if (arr[N - 1] > cur_max)
count++;
}
// Print the count
System.out.println(count);
}
// Driver Code
public static void main(String[] args)
{
// Given array
int[] arr = new int[] { 1, 2, 0, 7, 2, 0, 2, 0 };
// Size of the array
int N = arr.length;
numberOfIntegers(arr, N);
}
}
// This code is contributed by dharanendralv23
Python3
# Python program for the above approach # Function to count array elements # satisfying the given condition def numberOfIntegers(arr, N) : cur_max = 0 count = 0 # If there is only one # array element if (N == 1) : count = 1 else : # Traverse the array for i in range(N - 1): # Update the maximum element # encountered so far if (arr[i] > cur_max) : cur_max = arr[i] # Count the number of array elements # strictly greater than all previous # and immediately next elements if (arr[i] > arr[i + 1]) : count += 1 if (arr[N - 1] > cur_max) : count += 1 # Print the count print(count) # Driver Code # Given array arr = [ 1, 2, 0, 7, 2, 0, 2, 0 ] # Size of the array N = len(arr) numberOfIntegers(arr, N) # This code is contributed by sanjoy_62.
C#
// C# program for the above approach
using System;
class GFG
{
// Function to count array elements
// satisfying the given condition
static void numberOfIntegers(int[] arr, int N)
{
int cur_max = 0, count = 0;
// If there is only one
// array element
if (N == 1) {
count = 1;
}
else {
// Traverse the array
for (int i = 0; i < N - 1; i++) {
// Update the maximum element
// encountered so far
if (arr[i] > cur_max) {
cur_max = arr[i];
// Count the number of array elements
// strictly greater than all previous
// and immediately next elements
if (arr[i] > arr[i + 1]) {
count++;
}
}
}
if (arr[N - 1] > cur_max)
count++;
}
// Print the count
Console.WriteLine(count);
}
// Driver Code
static public void Main()
{
// Given array
int[] arr = new int[] { 1, 2, 0, 7, 2, 0, 2, 0 };
// Size of the array
int N = arr.Length;
numberOfIntegers(arr, N);
}
}
// This code is contributed by dharavendralv23
Javascript
<script>
// JavaScript implementation of the above approach
// Function to count array elements
// satisfying the given condition
function numberOfIntegers(arr, N)
{
let cur_max = 0, count = 0;
// If there is only one
// array element
if (N == 1) {
count = 1;
}
else
{
// Traverse the array
for (let i = 0; i < N - 1; i++)
{
// Update the maximum element
// encountered so far
if (arr[i] > cur_max)
{
cur_max = arr[i];
// Count the number of array elements
// strictly greater than all previous
// and immediately next elements
if (arr[i] > arr[i + 1])
{
count++;
}
}
}
if (arr[N - 1] > cur_max)
count++;
}
// Print the count
document.write(count);
}
// Driver code
// Given array
let arr = [ 1, 2, 0, 7, 2, 0, 2, 0 ];
// Size of the array
let N = arr.length;
numberOfIntegers(arr, N);
</script>
Producción:
2
Complejidad temporal: O(N)
Espacio auxiliar: O(1)
Publicación traducida automáticamente
Artículo escrito por dharanendralv23 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA