Arithmetic progression

You are given an array of numbers. Write a script to return true if the given array can be re-arranged to form an arithmetic progression, otherwise return false. A sequence of numbers is called an arithmetic progression if the difference between any two consecutive elements is the same.

Examples

Example 1
Input: @num = (1, 3, 5, 7, 9)
Output: true
Already AP with common difference 2.

Example 2
Input: @num = (9, 1, 7, 5, 3)
Output: true
The given array re-arranged like (1, 3, 5, 7,
   9) with common difference 2.

Example 3
Input: @num = (1, 2, 4, 8, 16)
Output: false
This is geometric progression and not arithmetic 
   progression.

Example 4
Input: @num = (5, -1, 3, 1, -3)
Output: true
The given array re-arranged like (-3, -1, 1, 3,
   5) with common difference 2.

Example 5
Input: @num = (1.5, 3, 0, 4.5, 6)
Output: true
The given array re-arranged like (0, 1.5, 3, 4.5,
   6) with common difference 1.5.

Analysis

As with task 1, I have taken the view that an arithmetic progression requires at least 3 elements.

That said, I do the obvious and sort the array, and then check that the increments between successive elements are the same.

This will always result in a positive increment, even for input such as (-1, -2, -3, -4) which will get sorted to (-4, -3, -2, -1) with an increment of 1.

This is a well-structured, practical implementation with good documentation and error handling. Peter demonstrates solid Perl programming practices while making reasonable design decisions based on their interpretation of the problem requirements.

This review may cover either or both challenges for this week.

Try it 

Try running the script with any input:

Your $array =

example: 13, 25, 37, 49

⤡

#!/usr/bin/perl

# Blog: http://ccgi.campbellsmiths.force9.co.uk/challenge

use v5.26;    # The Weekly Challenge - 2025-12-08
use utf8;     # Week 351 - task 2 - Arithmetic progression
use warnings; # Peter Campbell Smith
binmode STDOUT, ':utf8';
use Encode;

arithmetic_progression(9, 1, 7, 5, 3);
arithmetic_progression(-1, -2, -3, -4);
arithmetic_progression(-4, -3, -2, -1);
arithmetic_progression(1e6, 3e6, 5e6, 7e6, 9e6);
arithmetic_progression(111);
arithmetic_progression(111, 222);
arithmetic_progression(111, 222, 333);
arithmetic_progression(11/7, 14/7, 17/7, 29/7);

sub arithmetic_progression {
    
    my (@sorted, $increment, $j);
    
    # initialise
    say qq[\nInput:  (] . join(', ', @_) . ')';
    
    # need at lleast 3 elements
    if (@_ < 3) {
        say qq[Output: indeterminate - array too short];
        return;
    }
        
    # check for arithmetic progression
    @sorted = sort {$a <=> $b} @_;
    $increment = $sorted[1] - $sorted[0];
    
    for $j (1 .. @sorted - 2) {
        next if $sorted[$j + 1] = $sorted[$j] + $increment;
        say qq[Output: false as $sorted[$j + 1] - $sorted[$j] != $increment];
        return;
    }
    say qq[Output: true with increment of $increment];

}

13 lines of code

Output from script

Input:  (9, 1, 7, 5, 3)
Output: true with increment of 2

Input:  (-1, -2, -3, -4)
Output: true with increment of 1

Input:  (-4, -3, -2, -1)
Output: true with increment of 1

Input:  (1000000, 3000000, 5000000, 7000000, 9000000)
Output: true with increment of 2000000

Input:  (111)
Output: indeterminate - array too short

Input:  (111, 222)
Output: indeterminate - array too short

Input:  (111, 222, 333)
Output: true with increment of 111

Input:  (1.57142857142857, 2, 2.42857142857143,
   4.14285714285714)
Output: true with increment of 0.428571428571429