Progresión aritmética – Part 3

Una secuencia de números se llama progresión aritmética si la diferencia entre dos términos consecutivos es siempre la misma . En términos simples, significa que el siguiente número de la serie se calcula sumando un número fijo al número anterior de la serie. Por ejemplo, 2, 4, 6, 8, 10 es un AP porque la diferencia entre dos términos consecutivos de la serie (diferencia común) es la misma (4 – 2 = 6 – 4 = 8 – 6 = 10 – 8 = 2) . 
 

Hecho sobre la progresión aritmética: 
 

1. Término inicial: En una progresión aritmética, el primer número de la serie se llama término inicial.
2. Diferencia común: El valor por el cual los términos consecutivos aumentan o disminuyen se llama diferencia común.
3. El comportamiento de la progresión aritmética depende de la diferencia común d. Si la diferencia común es: positiva, entonces los miembros (términos) crecerán hacia el infinito positivo o negativo, entonces los miembros (términos) crecerán hacia el infinito negativo.

Fórmula del n ^-ésimo término de un AP: 
Si ‘a’ es el término inicial y ‘d’ es la diferencia común. Así, la fórmula explícita es 
 

Fórmula de la suma del ^enésimo término de AP: 
 

¿Cómo comprobamos si una serie es progresión aritmética o no?
 

1. Solución ingenua . 
   La idea es ordenar la array o serie dada. Después de ordenar, verifique si las diferencias entre elementos consecutivos son iguales o no. Si todas las diferencias son iguales, la progresión aritmética es posible. 
   A continuación se muestra la implementación de este enfoque: 
    

// C++ program to check if a given array
// can form arithmetic progression
#include <bits/stdc++.h>
using namespace std;
 
// Returns true if a permutation of arr[0..n-1]
// can form arithmetic progression
bool checkIsAP(int arr[], int n)
{
    if (n == 1)
        return true;
 
    // Sort array
    sort(arr, arr + n);
 
    // After sorting, difference between
    // consecutive elements must be same.
    int d = arr[1] - arr[0];
    for (int i = 2; i < n; i++)
        if (arr[i] - arr[i - 1] != d)
            return false;
 
    return true;
}
 
// Driven Program
int main()
{
    int arr[] = { 20, 15, 5, 0, 10 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    (checkIsAP(arr, n)) ? (cout << "Yes" << endl) : (cout << "No" << endl);
 
    return 0;
}

// Java program to check if a given array
// can form arithmetic progression
import java.util.Arrays;
 
class GFG {
 
    // Returns true if a permutation of
    // arr[0..n-1] can form arithmetic
    // progression
    static boolean checkIsAP(int arr[], int n)
    {
        if (n == 1)
            return true;
 
        // Sort array
        Arrays.sort(arr);
 
        // After sorting, difference between
        // consecutive elements must be same.
        int d = arr[1] - arr[0];
        for (int i = 2; i < n; i++)
            if (arr[i] - arr[i - 1] != d)
                return false;
 
        return true;
    }
 
    // driver code
    public static void main(String[] args)
    {
        int arr[] = { 20, 15, 5, 0, 10 };
        int n = arr.length;
 
        if (checkIsAP(arr, n))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}
 
// This code is contributed by Anant Agarwal.

# Python3 program to check if a given
# array can form arithmetic progression
 
# Returns true if a permutation of arr[0..n-1]
# can form arithmetic progression
def checkIsAP(arr, n):
    if (n == 1): return True
 
    # Sort array
    arr.sort()
 
    # After sorting, difference between
    # consecutive elements must be same.
    d = arr[1] - arr[0]
    for i in range(2, n):
        if (arr[i] - arr[i-1] != d):
            return False
 
    return True
 
# Driver code
arr = [ 20, 15, 5, 0, 10 ]
n = len(arr)
print("Yes") if(checkIsAP(arr, n)) else print("No")
 
# This code is contributed by Anant Agarwal.

// C# program to check if a given array
// can form arithmetic progression
using System;
 
class GFG {
 
    // Returns true if a permutation of
    // arr[0..n-1] can form arithmetic
    // progression
    static bool checkIsAP(int[] arr, int n)
    {
        if (n == 1)
            return true;
 
        // Sort array
        Array.Sort(arr);
 
        // After sorting, difference between
        // consecutive elements must be same.
        int d = arr[1] - arr[0];
        for (int i = 2; i < n; i++)
            if (arr[i] - arr[i - 1] != d)
                return false;
 
        return true;
    }
 
    // Driver Code
    public static void Main()
    {
        int[] arr = { 20, 15, 5, 0, 10 };
        int n = arr.Length;
 
        if (checkIsAP(arr, n))
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
 
// This code is contributed by vt_m.

<?php
// PHP program to check if
// a given array can form
// arithmetic progression
 
// Returns true if a permutation
// of arr[0..n-1] can form
// arithmetic progression
function checkIsAP($arr, $n)
{
    if ($n == 1)
        return true;
     
    // Sort array
    sort($arr);
     
    // After sorting, difference
    // between consecutive elements
    // must be same.
    $d = $arr[1] - $arr[0];
    for ($i = 2; $i < $n; $i++)
        if ($arr[$i] -
            $arr[$i - 1] != $d)
        return false;
     
    return true;
}
 
// Driver Code
$arr = array(20, 15, 5, 0, 10);
$n = count($arr);
 
if(checkIsAP($arr, $n))
echo "Yes";
else
echo "No";
                         
// This code is contributed
// by Sam007
?>

<script>
// Javascript program to check if a given array
// can form arithmetic progression
// Returns true if a permutation of arr[0..n-1]
// can form arithmetic progression
function compare(a, b) {
    if (a < b) {
        return -1;
    } else if (a > b) {
        return 1;
    } else {
        return 0;
    }
}
function checkIsAP( arr, n){
    if (n == 1)
        return true;
 
    // Sort array
    arr.sort(compare);
 
    // After sorting, difference between
    // consecutive elements must be same.
    let d = arr[1] - arr[0];
    for (let i = 2; i < n; i++)
        if (arr[i] - arr[i - 1] != d)
            return false;
 
    return true;
}
 
// Driven Program
let arr = [ 20, 15, 5, 0, 10 ];
let n = arr.length;
(checkIsAP(arr, n)) ? document.write("Yes <br>") : document.write("No <br>");
 
</script>

Producción:  

Yes

Complejidad Temporal: O(n Log n). 
Espacio Auxiliar: O(1)
 

Soluciones eficientes 
 

• Conjunto 1 (usar hash)
• Conjunto 2 (Usar clasificación por conteo)

Programa Básico relacionado con la Progresión Aritmética 
 

• Programa para suma de series aritméticas
• Programa para imprimir la serie Progresión Aritmética
• Progresión aritmética más larga con la diferencia común dada
• Compruebe si la progresión aritmética se puede formar a partir de la array dada
• Encuentra el número que falta en la progresión aritmética
• Encuentra N medias aritméticas entre A y B
• Suma de los números hasta N que son divisibles por 2 o 5
• Encuentre el primer elemento en AP que es múltiplo del primo dado

Más problemas relacionados con Progresión Aritmética 
 

• Suma de los primeros n términos de una serie dada 3, 6, 11, …..
• Razón de los términos m-ésimo y n-ésimo de un PA con una razón dada de sumas
• Probabilidad de que tres números elegidos al azar estén en AP
• Imprima todos los tripletes en una array ordenada que forman AP
• Programa para el N-ésimo término de la serie Progresión aritmética
• Suma de secuencia geométrica aritmética
• Recuento de subsecuencias AP (progresión aritmética) en una array

¡Artículos recientes sobre progresión aritmética!