Maximum difference between adjacent elements of list: Difference between revisions

Inline

Latest revision as of 13:59, 4 April 2024

Find maximum difference between adjacent elements of list.

Task

The list may have negative values, zero values, real numbers.

List = [1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3]

Output would be (which could have more verbiage):

  1,8 ==> 7
  2,9 ==> 7
  10,3 ==> 7

11l

Translation of: Python

F maxDeltas(ns)
   V pairs = zip(ns, ns[1..]).map((a, b) -> (abs(a - b), (a, b)))
   V delta = max(pairs, key' ab -> ab[0])[0]
   R pairs.filter(ab -> @delta == ab[0])

V maxPairs = maxDeltas([Float(1), 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3])

L(ab) maxPairs
   print(ab)

Output:

(7, (1, 8))
(7, (2, 9))
(7, (10, 3))

Action!

Library: Action! Tool Kit

Library: Action! Real Math

INCLUDE "H6:REALMATH.ACT"

DEFINE PTR="CARD"

PTR FUNC GetPtr(BYTE ARRAY a INT index)
RETURN (a+index*6)

PROC MaxDifference(BYTE ARRAY a INT len REAL POINTER maxDiff)
  INT i
  REAL diff
  REAL POINTER r1,r2

  IntToReal(0,maxDiff)
  FOR i=0 TO len-2
  DO
    r1=GetPtr(a,i)
    r2=GetPtr(a,i+1)
    RealAbsDiff(r1,r2,diff)
    IF RealGreaterOrEqual(diff,maxDiff) THEN
      RealAssign(diff,maxDiff)
    FI
  OD
RETURN

PROC PrintPairs(BYTE ARRAY a INT len,maxDiff)
  INT i
  REAL diff
  REAL POINTER r1,r2

  FOR i=0 TO len-2
  DO
    r1=GetPtr(a,i)
    r2=GetPtr(a,i+1)
    RealAbsDiff(r1,r2,diff)
    IF RealEqual(diff,maxDiff) THEN
      Print("  AbsDiff(") PrintR(r1)
      Print(", ") PrintR(r2)
      Print(") = ") PrintRE(maxDiff)
    FI
  OD
RETURN

PROC Decode(CHAR ARRAY s BYTE ARRAY a INT POINTER len)
  BYTE i,start,length
  CHAR ARRAY item,tmp(10)
  REAL POINTER r

  len^=0 i=1
  WHILE i<=s(0)
  DO
    start=i
    WHILE i<=s(0) AND s(i)#32
    DO
      i==+1
    OD
    length=i-start
    SCopyS(tmp,s,start,i-1)
    r=GetPtr(a,len^)
    ValR(tmp,r)
    len^==+1
    i==+1
  OD
RETURN

PROC Test(CHAR ARRAY s)
  BYTE ARRAY a(200)
  INT len
  REAL maxDiff

  PrintF("Max difference in [%S] is ",s)
  Decode(s,a,@len)
  MaxDifference(a,len,maxDiff)
  PrintRE(maxDiff)
  PrintPairs(a,len,maxDiff) PutE()
RETURN

PROC Main()
  Put(125) PutE() ;clear the screen

  Test("1 8 2 -3 0 1 1 -2.3 0 5.5 8 6 2 9 11 10 3")
  Test("0.12 -0.04 0.34 0.72 0.34 0.27 -0.1")
  Test("10E30 20E30 15E30 5E30 -5E30")
RETURN

Output:

Screenshot from Atari 8-bit computer

Max difference in [1 8 2 -3 0 1 1 -2.3 0 5.5 8 6 2 9 11 10 3] is 7
  AbsDiff(1, 8) = 7
  AbsDiff(2, 9) = 7
  AbsDiff(10, 3) = 7

Max difference in [0.12 -0.04 0.34 0.72 0.34 0.27 -0.1] is .38
  AbsDiff(-0.04, .34) = .38
  AbsDiff(.34, .72) = .38
  AbsDiff(.72, .34) = .38

Max difference in [10E30 20E30 15E30 5E30 -5E30] is 1.0E+31
  AbsDiff(1.0E+31, 2.0E+31) = 1.0E+31
  AbsDiff(1.5E+31, 5E+30) = 1.0E+31
  AbsDiff(5E+30, -5E+30) = 1.0E+31

Ada

-- Find the maximum absolute difference between adjacent values in a list,  and output all pairs with that difference
-- J. Carter     2023 Apr
-- Uses the PragmAda Reusable Components (https://github.com/jrcarter/PragmARC)

with Ada.Text_IO;
with PragmARC.Images;

procedure List_Max_Diff is
   function Float_Image is new PragmARC.Images.Float_Image (Number => Float);
   function Image (Number : in Float) return String;
   -- Returns the image of Number without a decimal point or fractional digits if the fractional part is zero
   
   function Image (Number : in Float) return String is
      Result : constant String := Float_Image (Number, Aft => 0, Exp => 0);
   begin -- Image
      if Result'Length > 1 and then Result (Result'Last - 1 .. Result'Last) = ".0" then
         return Result (Result'First .. Result'Last - 2);
      end if;
      
      return Result;
   end Image;
   
   type Float_List is array (Positive range <>) of Float with Dynamic_Predicate => Float_List'First = 1;
   
   List : constant Float_List := (1.0, 8.0, 2.0, -3.0, 0.0, 1.0, 1.0, -2.3, 0.0, 5.5, 8.0, 6.0, 2.0, 9.0, 11.0, 10.0, 3.0);
   
   Max : Float := -1.0;
begin -- List_Max_Diff
   Find : for I in 1 .. List'Last - 1 loop
      Max := Float'Max (abs (List (I) - List (I + 1) ), Max);
   end loop Find;
   
   Print : for I in 1 .. List'Last - 1 loop
      if abs (List (I) - List (I + 1) ) = Max then
         Ada.Text_IO.Put_Line (Item => Image (List (I) ) & ',' & Image (List (I + 1) ) & " ==> " & Image (Max) );
      end if;
   end loop Print;
end List_Max_Diff;

Output:

1,8 ==> 7
2,9 ==> 7
10,3 ==> 7

ALGOL 68

BEGIN # find the maximum difference between consecutive list elements         #
    # returns the maximum difference between pairs of elements of list        #
    OP   MAXDELTA = ( []REAL list )REAL:
         BEGIN
            REAL max diff := 0;
            FOR i FROM LWB list TO UPB list - 1 DO
                REAL delta = ABS ( list[ i ] - list[ i + 1 ] );
                IF delta > max diff THEN
                    max diff := delta # found a higher difference             #
                FI
            OD;
            max diff
         END; # MAXDELTA #
    # returns r converted to a string with trailing 0 decimal places removed  #
    OP   TOSTRING = ( REAL r )STRING:
         BEGIN
            STRING result  := fixed( r, 0, 10 );
            IF result[ LWB result ] = "." THEN result := "0" + result FI;
            INT    r end   := UPB result;
            INT    r start := LWB result;
            WHILE IF r end <= r start THEN FALSE ELSE result[ r end ] = "0" FI DO
               r end -:= 1
            OD;
            IF r end > LWB result THEN
                # if all decimal places were "0", remove the "." as well      #
                IF result[ r end ] = "." THEN r end -:= 1 FI
            FI;
            result[ r start : r end ]
         END; # TOSTRING #
    # test the MAXDELTA operator                                              #
    PROC test max delta = ( []REAL list )VOID:
         BEGIN
            REAL max diff = MAXDELTA list;
            print( ( "Max difference [" ) );
            FOR i FROM LWB list TO UPB list DO
                print( ( " ", TOSTRING list[ i ] ) )
            OD;
            print( ( " ] is ", TOSTRING max diff, ":",  newline ) );
            FOR i FROM LWB list TO UPB list - 1 DO
                IF REAL diff = ABS ( list[ i ] - list[ i + 1 ] );
                   diff = max diff
                THEN
                    print( ( "    ", TOSTRING list[ i ], ", ", TOSTRING list[ i + 1 ]
                           , " ==> ", TOSTRING diff
                           , newline
                           )
                         )
                FI
            OD
         END; # test max delta #
    # task test case                                                          #
    test max delta( ( 1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3 ) );
    # additional test cases                                                   #
    test max delta( ( -1.1, -1.2 ) ); test max delta( ( pi, pi, pi ) );
    test max delta( ( )            ); test max delta( ( 776.591 )    )
END

Output:

Max difference [ 1 8 2 -3 0 1 1 -2.3 0 5.5 8 6 2 9 11 10 3 ] is 7:
    1, 8 ==> 7
    2, 9 ==> 7
    10, 3 ==> 7
Max difference [ -1.1 -1.2 ] is 0.1:
    -1.1, -1.2 ==> 0.1
Max difference [ 3.1415926536 3.1415926536 3.1415926536 ] is 0:
    3.1415926536, 3.1415926536 ==> 0
    3.1415926536, 3.1415926536 ==> 0
Max difference [ ] is 0:
Max difference [ 776.591 ] is 0:

ALGOL W

begin % find the maximum difference between consecutive list elements         %
    % returns the maximum difference between pairs of elements of list        %
    %         the lower and upper bounds of list must be specified in lb & ub %
    real procedure maxDelta ( real    array list ( * )
                            ; integer value lb, ub
                            ) ;
    begin
        real maxDiff;
        maxDiff := 0;
        for i := lb until ub - 1 do begin
            real delta;
            delta := abs ( list( i ) - list( i + 1 ) );
            if delta > maxDiff then maxDiff := delta % found a higher difference %
        end for_i;
        maxDiff
    end maxDelta;
    % test the maxDelta procedure                                             %
    procedure testMaxDelta ( real    array list ( * )
                           ; integer value lb, ub, rw, dp
                           ) ;
    begin
        real maxDiff;
        maxDiff := maxDelta( list, lb, ub );
        write( s_w := 0, "Max difference [" );
        for i := lb until ub do begin
            writeon( r_format := "A", r_w := rw, r_d := dp, s_w := 0, " ", list( i ) );
        end for_i;
        writeon( r_format := "A", r_w := rw, r_d := dp, s_w := 0, " ] is ", maxDiff, ":" );
        for i := lb until ub - 1 do begin
            real diff;
            diff := abs ( list( i ) - list( i + 1 ) );
            if diff = maxDiff then begin
                write( r_format := "A", r_w := rw, r_d := dp, s_w := 0, "    ", list( i ), ", ", list( i + 1 ), " ==> ", diff );
            end if_diff_eq_maxDiff
         end for_i
    end testMaxDelta;
    begin % task test case                                                    %
        integer tPos;
        real array tc( 1 :: 17 );
        tPos := 0;
        for i := 1, 8, 2, -3, 0, 1, 1, -23, 0, 55, 8, 6, 2, 9, 11, 10, 3 do begin
            tPos       := tPos + 1;
            tc( tPos ) := i
        end for_i;
        tc( 8 ) := -2.3; tc( 10 ) := 5.5;
        testMaxDelta( tc, 1, 17, 4, 1 )
    end;
    begin % additional test cases                                             %
        integer tPos;
        real array tc( 1 :: 3 );
        tc( 1 ) := -1.1; tc( 2 ) := -1.2; testMaxDelta( tc, 1, 2, 4, 1  );
        for i := 1 until 3 do tc( i ) := pi;
        testMaxDelta( tc, 1, 3, 6, 4 );
        testMaxDelta( tc, 1, 0, 3, 1 );
        tc( 1 ) := 776.591;
        testMaxDelta( tc, 1, 1, 6, 3 )
    end
end.

Output:

Max difference [  1.0  8.0  2.0 -3.0  0.0  1.0  1.0 -2.3  0.0  5.5  8.0  6.0  2.0  9.0 11.0 10.0  3.0 ] is  7.0:
     1.0,  8.0 ==>  7.0
     2.0,  9.0 ==>  7.0
    10.0,  3.0 ==>  7.0
Max difference [ -1.1 -1.2 ] is  0.1:
    -1.1, -1.2 ==>  0.1
Max difference [ 3.1416 3.1416 3.1416 ] is 0.0000:
    3.1416, 3.1416 ==> 0.0000
    3.1416, 3.1416 ==> 0.0000
Max difference [ ] is 0.0:
Max difference [ 776.591 ] is  0.000:

APL

Works with: Dyalog APL

maxdiff ← (⊢((⌈/⊢),⊣(⌿⍨)⊢=(⌈/⊢))(|-)/)∘(↑2,/⊢)

Output:

      maxdiff 1 8 2 ¯3 0 1 1 ¯2.3 0 5.5 8 6 2 9 11 10 3
7  1 8
7  2 9
7 10 3

Arturo

maximumAdjacentDifference: function [L][
    result: [[[] 0]]

    loop 0..(size L)-2 'a [
        diff: abs (y: <= L\[a+1]) - (x: <= L\[a])

        if diff >= last maximum result => last ->
            result: (select result 'x -> diff = last x) ++ @[@[@[x,y], diff]]
    ]
    maxLen: result\0\1
    result: @[unique map result 'x -> first x, maxLen]
    return result
]

lst: @[1,8,2,neg 3,0,1,1,neg 2.3,0,5.5,8,6,2,9,11,10,3]

diffs: maximumAdjacentDifference lst

loop diffs\0 'd ->
    print [d "->" diffs\1]

Output:

[1 8] -> 7 
[2 9] -> 7 
[10 3] -> 7

AutoHotkey

List := [1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3]
mxDiff := []

loop % List.Count() -1
    mxDiff[d := Abs(list[A_Index+1] - list[A_Index])] .= list[A_Index] ", " list[A_Index+1] " ==> " d "`n"

MsgBox % result := Trim(mxDiff[mxDiff.MaxIndex()], "`n")

Output:

1, 8 ==> 7
2, 9 ==> 7
10, 3 ==> 7

AWK

# syntax: GAWK -f MAXIMUM_DIFFERENCE_BETWEEN_ADJACENT_ELEMENTS_OF_LIST.AWK
BEGIN {
    list = "1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3"
    n = split(list,arr,",")
    for (i=1; i<n; i++) {
      a = arr[i]
      b = arr[i+1]
      if (abs(a-b) == highest) {
        sets = sprintf("%s%s,%s  ",sets,a,b)
      }
      else if (abs(a-b) > highest) {
        highest = abs(a-b)
        sets = sprintf("%s,%s  ",a,b)
      }
    }
    printf("%s: %s\n",highest,sets)
    exit(0)
}
function abs(x) { if (x >= 0) { return x } else { return -x } }

Output:

7: 1,8  2,9  10,3

BASIC

QBasic

Works with: QBasic version 1.1

Works with: QuickBasic version 4.5

maxdist = 0
DIM lista(0 TO 16)
FOR i = 0 TO UBOUND(lista)
    READ lista(i)
NEXT i

PRINT "Maximum difference between adjacent elements of lista is:"
FOR i = 0 TO UBOUND(lista) - 1
    dist = ABS(lista(i) - lista(i + 1))
    IF dist > maxdist THEN maxdist = dist
NEXT i

FOR i = 0 TO UBOUND(lista) - 1
    dist = ABS(lista(i) - lista(i + 1))
    IF dist = maxdist THEN PRINT lista(i); ", "; lista(i + 1); " ==> "; maxdist
NEXT i

DATA 1., 8., 2., -3., 0., 1., 1., -2.3, 0., 5.5, 8., 6., 2., 9., 11., 10., 3.

Output:

Same as FreeBASIC entry.

BASIC256

arraybase 1
maxdist = 0
dim lista = {1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3}

print "Maximum difference between adjacent elements of lista is:"
for i = 1 to lista[?]-1
	dist = abs(lista[i] - lista[i+1])
	if dist > maxdist then maxdist = dist
next i

for i = 1 to  lista[?]-1
	dist = abs(lista[i] - lista[i+1])
	if dist = maxdist then print lista[i] & ", " & lista[i+1] & " ==> " & maxdist
next i

Output:

Same as FreeBASIC entry.

True BASIC

LET maxdist = 0
DIM lista(0 TO 16)
FOR i = 0 TO UBOUND(lista)
    READ lista(i)
NEXT i
PRINT "Maximum difference between adjacent elements of lista is:"
FOR i = 0 TO UBOUND(lista)-1
    LET dist = ABS(lista(i)-lista(i+1))
    IF dist > maxdist THEN LET maxdist = dist
NEXT i
FOR i = 0 TO UBOUND(lista)-1
    LET dist = ABS(lista(i)-lista(i+1))
    IF dist = maxdist THEN PRINT lista(i); ", "; lista(i+1); " ==> "; maxdist
NEXT i
DATA 1., 8., 2., -3., 0., 1., 1., -2.3, 0., 5.5, 8., 6., 2., 9., 11., 10., 3.
END

Output:

Same as FreeBASIC entry.

Yabasic

maxdist = 0
dim lista(16)
lista(0) =  1  : lista(1)  = 8
lista(2) =  2  : lista(3)  = -3
lista(4) =  0  : lista(5)  = 1
lista(6) =  1  : lista(7)  = -2.3
lista(8) =  0  : lista(9)  = 5.5
lista(10) = 8  : lista(11) = 6
lista(12) = 2  : lista(13) = 9
lista(14) = 11 : lista(15) = 10
lista(16) = 3

print "Maximum difference between adjacent elements of lista is:"
for i = 0 to arraysize(lista(),1)-1
    dist = abs(lista(i) - lista(i+1))
    if dist > maxdist  maxdist = dist
next i

for i = 0 to arraysize(lista(),1)-1
    dist = abs(lista(i) - lista(i+1))
    if dist = maxdist  print lista(i), ", ", lista(i+1), " ==> ", maxdist
next i

Output:

Same as FreeBASIC entry.

C

Translation of: Wren

#include <stdio.h>
#include <math.h>

typedef struct {
    double x;
    double y;
} pair;

int main() {
    double list[17] = {1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8,6, 2, 9, 11, 10, 3};
    double diff, maxDiff = -1;
    pair maxPairs[5];
    int i, count = 0;
    for (i = 1; i < 17; ++i) {
        diff = fabs(list[i-1] - list[i]);
        if (diff > maxDiff) {
            maxDiff = diff;
            maxPairs[count++] = (pair){list[i-1], list[i]};
        } else if (diff == maxDiff) {
            maxPairs[count++] = (pair){list[i-1], list[i]};
        }
    }
    printf("The maximum difference between adjacent pairs of the list is: %g\n", maxDiff);
    printf("The pairs with this difference are: ");
    for (i = 0; i < count; ++i) printf("[%g, %g] ", maxPairs[i].x, maxPairs[i].y);
    printf("\n");
    return 0;
}

Output:

The maximum difference between adjacent pairs of the list is: 7
The pairs with this difference are: [1, 8] [2, 9] [10, 3]

C++

#include <iostream>
#include <iterator>
#include <vector>
#include <utility>
#include <cstdlib>
#include <algorithm>

//supposing example numbers are entered!
int main( ) {
   std::cout << "Enter some doubles, separated by blanks, e to end!\n" ;
   std::vector<double> numbers { std::istream_iterator<double>{ std::cin } , 
      std::istream_iterator<double>{} } ;
   std::vector<std::pair<int , int>> neighbours ;
   for ( int i = 0 ; i < numbers.size( ) - 1 ; i++ ) 
      neighbours.push_back( std::make_pair( numbers[i] , numbers[ i + 1 ] )) ;
   std::sort( neighbours.begin( ) , neighbours.end( ) , []( auto p1 , auto p2 ) {
         return std::abs( p1.first - p1.second ) > std::abs( p2.first - p2.second )
         ; } ) ;
   double maximum = std::abs( neighbours[0].first - neighbours[0].second ) ;
   int pos = 0 ;
   while ( std::abs(neighbours[pos].first - neighbours[pos].second ) == maximum ) {
      std::cout << neighbours[pos].first << ',' << neighbours[pos].second <<
         " ==> " << maximum << '\n' ;
      pos++ ;
      }
   return 0 ;
}

Output:

1,8 ==> 7
2,9 ==> 7
10,3 ==> 7

Delphi

Works with: Delphi version 6.0

Library: SysUtils,StdCtrls

{Data type to hold difference info}

type TDiffInfo = record
 Diff,N1,N2: double;
 end;

{Array of different info}

type TDiffArray = array of TDiffInfo;

procedure FindMaximumDifference(List: array of double; var DiffArray: TDiffArray);
{Analyze data and return list of differnces}
var I: integer;
var Diff,MaxDiff: double;
begin
MaxDiff:=0;
for I:=0 to High(List)-1 do
	begin
	Diff:=Abs(List[I+1]-List[I]);
	if Diff>=MaxDiff then
		begin
		MaxDiff:=Diff;
		SetLength(DiffArray,Length(DiffArray)+1);
		DiffArray[High(DiffArray)].Diff:=MaxDiff;
		DiffArray[High(DiffArray)].N1:=List[I];
		DiffArray[High(DiffArray)].N2:=List[I+1];
		end
	end;
end;

procedure MaximumAdjacentDifference(Memo: TMemo);
var DA: TDiffArray;
var I: integer;
begin
FindMaximumDifference([1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3],DA);
for I:=0 to High(DA) do
	begin
	Memo.Lines.Add(Format('abs(%4.1f - %4.1f) = %4.1f',[DA[I].N1,DA[I].N2,DA[I].Diff]));
	end;
end;

Output:

abs( 1.0 -  8.0) =  7.0
abs( 2.0 -  9.0) =  7.0
abs(10.0 -  3.0) =  7.0

EasyLang

list[] = [ 1 8 2 -3 0 1 1 -2.3 0 5.5 8 6 2 9 11 10 3 ]
for i = 2 to len list[]
   dist = abs (list[i - 1] - list[i])
   max = higher dist max
.
for i = 2 to len list[]
   if abs (list[i - 1] - list[i]) = max
      print list[i - 1] & "," & list[i] & " ==> " & dist
   .
.

Output:

1,8 ==> 7
2,9 ==> 7
10,3 ==> 7

F#

// Max diff 'twix adj elems. Nigel Galloway: July 18th., 2021
let n,g=[1;8;2;-3;0;1;1;-2;3;0;5;5;8;6;2;9;11;10;3]|>List.pairwise|>List.groupBy(fun(n,g)->abs(n-g))|>List.maxBy fst in printfn "Pairs %A have the max diff of %d" g n

Output:

Pairs [(1, 8); (2, 9); (10, 3)] have the max diff of 7

Factor

Works with: Factor version 0.99 2021-06-02

USING: assocs grouping math prettyprint sequences ;

: max-diff ( seq -- assoc )
    2 clump [ first2 - abs ] collect-by >alist supremum ;

{ 1 8 2 -3 0 1 1 -2.3 0 5.5 8 6 2 9 11 10 3 } max-diff .

Output:

{ 7 V{ { 1 8 } { 2 9 } { 10 3 } } }

Free Pascal

Translation of: Pascal

program maximumDifferenceBetweenAdjacentElementsOfList(output);
type
  tmyReal = extended;
  tmyList = array of tmyReal;
const
  input: tmyList = (1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3);
  procedure  OutSameDistanceInList(Dist:tmyReal;const list: tmyList);
  var
    currentDistance : tmyReal;
    i : integer;
  begin
    for i := 0 to High(List) - 1 do
    begin
      currentDistance := abs(list[i] - list[succ(i)]);
      if currentDistance = dist then
         writeln('idx : ',i:4,' values ',list[i],' ',list[i+1]);
    end;
    writeln;
  end;

  function internalDistance(const list: tmyList): tmyReal;
  var
    i: integer;
    maximumDistance, currentDistance: tmyReal;
  begin
    maximumDistance := 0.0;
    for i := 0 to High(List) - 1 do
    begin
      currentDistance := abs(list[i] - list[succ(i)]);
      if currentDistance > maximumDistance then
      begin
        maximumDistance := currentDistance;
      end;
    end;
    internalDistance := maximumDistance;
  end;

var
  list: tmyList;
  foundDistance : tmyReal;
begin
  list := input;
  if length(list) > 0 then
  Begin
    foundDistance := internalDistance(list);
    OutSameDistanceInList(foundDistance,list);
  end;
  {$IFDEF WINDOWS}
  readln;
  {$ENDIF}
end.

Output:

idx :    0 values  1.0000000000000000E+000  8.0000000000000000E+000
idx :   12 values  2.0000000000000000E+000  9.0000000000000000E+000
idx :   15 values  1.0000000000000000E+001  3.0000000000000000E+000

FreeBASIC

Dim As Single Dist, MaxDist = 0
Dim As Single List(16) => {1., 8., 2., -3., 0., 1., 1., -2.3, 0., 5.5, 8., 6., 2., 9., 11., 10., 3.}

Print !"Maximum difference between adjacent elements of list is:"
For i As Integer = 0 To Ubound(List)
    Dist = Abs(List(i) - List(i+1))
    If Dist > MaxDist Then MaxDist = Dist
Next i

For i As Integer = 0 To Ubound(List)
    Dist = Abs(List(i) - List(i+1))
    If Dist = MaxDist Then Print List(i) & ", " & List(i+1) & " ==> " & MaxDist
Next i

Output:

Maximum difference between adjacent elements of lista is:
1, 8 ==> 7
2, 9 ==> 7
10, 3 ==> 7

Go

package main

import (
    "fmt"
    "math"
)

func main() {
    list := []float64{1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3}
    maxDiff := -1.0
    var maxPairs [][2]float64
    for i := 1; i < len(list); i++ {
        diff := math.Abs(list[i-1] - list[i])
        if diff > maxDiff {
            maxDiff = diff
            maxPairs = [][2]float64{{list[i-1], list[i]}}
        } else if diff == maxDiff {
            maxPairs = append(maxPairs, [2]float64{list[i-1], list[i]})
        }
    }
    fmt.Println("The maximum difference between adjacent pairs of the list is:", maxDiff)
    fmt.Println("The pairs with this difference are:", maxPairs)
}

Output:

The maximum difference between adjacent pairs of the list is: 7
The pairs with this difference are: [[1 8] [2 9] [10 3]]

Haskell

import Data.List (maximumBy)
import Data.Ord (comparing)

maxDeltas :: (Num a, Ord a) => [a] -> [(a, (a, a))]
maxDeltas xs = filter ((delta ==) . fst) pairs
  where
    pairs =
      zipWith
        (\a b -> (abs (a - b), (a, b)))
        xs
        (tail xs)
    delta = fst $ maximumBy (comparing fst) pairs

main :: IO ()
main =
  mapM_ print $
    maxDeltas [1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3]

Output:

(7.0,(1.0,8.0))
(7.0,(2.0,9.0))
(7.0,(10.0,3.0))

J

maxdiff=: [: (,.|@-/"1) 2(,/\ (#~ (=>./)@:|) -/\) ]

Output:

   maxdiff 1 8 2 _3 0 1 1 _2.3 0 5.5 8 6 2 9 11 10 3
 1 8 7
 2 9 7
10 3 7
   (}:,&":' ==> ',&":{:)"1 maxdiff 1 8 2 _3 0 1 1 _2.3 0 5.5 8 6 2 9 11 10 3
1 8 ==> 7 
2 9 ==> 7 
10 3 ==> 7

jq

Works with: jq

Works with gojq, the Go implementation of jq

def maximally_different_adjacent_pairs:
  . as $in
  | reduce range(1; length) as $i ({ maxDiff: -1};
      (($in[$i-1] - $in[$i])|length) as $diff  # length being abs
      | if $diff > .maxDiff
        then .maxDiff = $diff
        | .maxPairs = [[$in[$i-1], $in[$i]]]
        elif $diff == .maxDiff
        then .maxPairs += [[$in[$i-1], $in[$i]]]
	else .
	end
      );

# Example:
[1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8,6, 2, 9, 11, 10, 3]
| maximally_different_adjacent_pairs

Output:

{"maxDiff":7,"maxPairs":[[1,8],[2,9],[10,3]]}

Julia

function maxadjacentdiffs(list)
    pairs, maxδ = Pair{eltype(list)}[], abs(zero(eltype(list)))
    for i in eachindex(list[begin:end-1])
        x, y = list[i], list[i + 1]
        if (δ = abs(x - y)) == maxδ
            push!(pairs, x => y)
        elseif δ > maxδ
            maxδ, pairs = δ, [x => y]
        end
    end
    return maxδ, pairs
end

diff, pairs = maxadjacentdiffs(Real[1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3])

foreach(p -> println(p[1], ", ", p[2], " ==> ", diff), pairs)

Output:

1, 8 ==> 7
2, 9 ==> 7
10, 3 ==> 7

Mathematica/Wolfram Language

l = {1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3};
diff = Abs@Differences[l];
m = Max[diff];
pos = Flatten[Position[diff, m]];
Column[Part[l, # ;; # + 1] -> m & /@ pos]

Output:

{1,8}->7
{2,9}->7
{10,3}->7

Nim

import strformat, strutils

type Pair = (float, float)

func `$`(p: Pair): string = &"({p[0]:g}, {p[1]:g})"

func maxdiff(list: openArray[float]): tuple[diff: float; list: seq[Pair]] =
  assert list.len >= 2
  result = (diff: -1.0, list: @[])
  var prev = list[0]
  for n in list[1..^1]:
    let d = abs(n - prev)
    if d > result.diff:
      result.diff = d
      result.list = @[(prev, n)]
    elif d == result.diff:
      result.list.add (prev, n)
    prev = n

let list = [float 1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3]
let (diff, pairs) = list.maxdiff()

echo &"The maximum difference between adjacent pairs of the list is: {diff:g}"
echo "The pairs with this difference are: ", pairs.join(" ")

Output:

The maximum difference between adjacent pairs of the list is: 7
The pairs with this difference are: (1, 8) (2, 9) (10, 3)

OCaml

let rec fold_pairwise f m = function
  | a :: (b :: _ as t) -> fold_pairwise f (f m a b) t
  | _ -> m

let pair_to_str (a, b) =
  Printf.sprintf "(%g, %g)" a b

let max_diffs =
  let next m a b =
    match abs_float (b -. a), m with
    | d', (d, _) when d' > d -> d', [a, b]
    | d', (d, l) when d' = d -> d', (a, b) :: l
    | _ -> m
  in fold_pairwise next (0., [])

let () =
  let d, l = max_diffs [1.;8.;2.;-3.;0.;1.;1.;-2.3;0.;5.5;8.;6.;2.;9.;11.;10.;3.] in
  List.rev_map pair_to_str l |> String.concat " " |> Printf.printf "%g: %s\n" d

Output:

7: (1, 8) (2, 9) (10, 3)

Pascal

The following program needs an ISO 7185 Standard “unextended” Pascal, level 1, compliant compiler.

program maximumDifferenceBetweenAdjacentElementsOfList(output);

function internalDistance(
		list: array[indexMinimum..indexMaximum: integer] of real
	): real;
var
	i: integer;
	maximumDistance, currentDistance: real;
begin
	maximumDistance := 0.0;
	
	for i := indexMinimum to pred(indexMaximum) do
	begin
		currentDistance := abs(list[i] - list[succ(i)]);
		
		if currentDistance > maximumDistance then
		begin
			maximumDistance := currentDistance
		end
	end;
	
	internalDistance := maximumDistance
end;

var
	list: array[1..2] of real;
begin
	list[1] := 1.0; list[2] := 8.0;
	writeLn(internalDistance(list));
end.

Perl

#!/usr/bin/perl

use strict;
use warnings;
use List::Util qw( reduce max );

my @list = (1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3);

my %diffs;
reduce { $diffs{ abs $a - $b } .= " $a,$b"; $b } @list;
my $max = max keys %diffs;
print "$_ ==> $max\n" for split ' ', $diffs{ $max };

Output:

1,8 ==> 7
2,9 ==> 7
10,3 ==> 7

Phix

procedure differences(sequence s)
    sequence d, mx = {0,""}, mn = mx
    atom av = 0
    function fall(integer fn, sequence d, s)
        atom m = fn(d)
        sequence p = find_all(m,d)
        for i=1 to length(p) do
            integer pi = p[i], pj = pi+1
            p[i] = sprintf("s[%d..%d]=%V",{pi,pj,s[pi..pj]})
        end for
        return {m,", occurring at "&join(p,", ")}
    end function
    if length(s)>=2 then
        d = sq_abs(sq_sub(s[1..-2],s[2..-1]))
        mx = fall(maxsq, d, s)
        mn = fall(minsq, d, s)
        av = sum(d)/length(d)
    end if
    printf(1,"sequence: %V\n",{s})
    printf(1,"max difference is %g%s\n",mx)
    printf(1,"min difference is %g%s\n",mn)
    printf(1,"avg difference is %.7g\n\n",av)
end procedure
differences({1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3})
differences({-1.1,-1.2})
differences({})
differences({776.591})

Output:

sequence: {1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3}
max difference is 7, occurring at s[1..2]={1,8}, s[13..14]={2,9}, s[16..17]={10,3}
min difference is 0, occurring at s[6..7]={1,1}
avg difference is 3.6625

sequence: {-1.1,-1.2}
max difference is 0.1, occurring at s[1..2]={-1.1,-1.2}
min difference is 0.1, occurring at s[1..2]={-1.1,-1.2}
avg difference is 0.1

sequence: {}
max difference is 0
min difference is 0
avg difference is 0

sequence: {776.591}
max difference is 0
min difference is 0
avg difference is 0

Picat

import util.

main =>
  L = [1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3],
  Diffs = findall([Diff,A,B], (nextto(A,B,L), Diff = abs(A-B))),
  MaxDiff = max([Diff : [Diff,_,_] in Diffs]),
  println(MaxDiff=[[A,B] : [Diff,A,B] in Diffs, Diff == MaxDiff]),
  nl.

Output:

7 = [[1,8],[2,9],[10,3]]

Here is an alternative way to get the pairwise differences, using zip/2:

  % ...
  Diffs = [[abs(A-B),A,B] : {A,B} in zip(L.butlast,L.tail)],
  % ...

% Returns all element of L but the last
butlast(L) = L[1..L.len-1].

Python

'''Maximum difference between adjacent numbers in list'''


# maxDeltas [Float] -> [(Float, (Float, Float))]
def maxDeltas(ns):
    '''Each of the maximally differing successive pairs
       in ns, each preceded by the value of the difference.
    '''
    pairs = [
        (abs(a - b), (a, b)) for a, b
        in zip(ns, ns[1:])
    ]
    delta = max(pairs, key=lambda ab: ab[0])[0]

    return [
        ab for ab in pairs
        if delta == ab[0]
    ]


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Each of the maximally differing pairs in a list'''

    maxPairs = maxDeltas([
        1, 8, 2, -3, 0, 1, 1, -2.3, 0,
        5.5, 8, 6, 2, 9, 11, 10, 3
    ])

    for ab in maxPairs:
        print(ab)


# MAIN ---
if __name__ == '__main__':
    main()

Output:

(7, (1, 8))
(7, (2, 9))
(7, (10, 3))

Raku

sub max-diff (*@list) {
   return 0 if +@list < 2;
   my $max = @list.rotor(2 => -1).max({ (.[0] - .[1]).abs }).map( (* - *).abs )[0];
   "$max @ elements { @list.rotor(2 => -1).grep( { (.[0] - .[1]).abs == $max } ).gist }"
}


sub min-diff (*@list) {
   return 0 if +@list < 2;
   my $min = @list.rotor(2 => -1).min({ (.[0] - .[1]).abs }).map( (* - *).abs )[0];
   "$min @ elements { @list.rotor(2 => -1).grep( { (.[0] - .[1]).abs == $min } ).gist }"
}


sub avg-diff (*@list) { (+@list > 1) ?? (@list.sum / +@list) !! 0 }


# TESTING

for (
      [ 1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3 ]
     ,[(rand × 1e6) xx 6]
     ,[ e, i, τ, π, ∞ ]
     ,[ 1.9+3.7i, 2.07-13.2i, 0.2+-2.2i, 4.6+0i ]
     ,[ 6 ]
     ,[]
     ,[<One Two Three>]
    )
-> @list {
    say 'List: ', ~ @list.raku;
    for ('  Maximum', &max-diff ,'  Minimum', &min-diff, '  Average', &avg-diff)
    -> $which, &sub {
        say "$which distance between list elements: " ~ &sub(@list);
    }
    say '';
}

Output:

List: [1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3]
  Maximum distance between list elements: 7 @ elements ((1 8) (2 9) (10 3))
  Minimum distance between list elements: 0 @ elements ((1 1))
  Average distance between list elements: 3.658824

List: [480470.3324944039e0, 719954.3173377671e0, 648221.5674277907e0, 340053.78585537826e0, 540629.6741075241e0, 4336.700602958543e0]
  Maximum distance between list elements: 536292.9735045655 @ elements ((540629.6741075241 4336.700602958543))
  Minimum distance between list elements: 71732.74990997638 @ elements ((719954.3173377671 648221.5674277907))
  Average distance between list elements: 455611.06297097047

List: [2.718281828459045e0, <0+1i>, 6.283185307179586e0, 3.141592653589793e0, Inf]
  Maximum distance between list elements: Inf @ elements ((3.141592653589793 Inf))
  Minimum distance between list elements: 2.896386731590008 @ elements ((2.718281828459045 0+1i))
  Average distance between list elements: Inf+0.2i

List: [<1.9+3.7i>, <2.07-13.2i>, <0.2-2.2i>, <4.6+0i>]
  Maximum distance between list elements: 16.900855007957436 @ elements ((1.9+3.7i 2.07-13.2i))
  Minimum distance between list elements: 4.919349550499537 @ elements ((0.2-2.2i 4.6+0i))
  Average distance between list elements: 2.1925-2.925i

List: [6]
  Maximum distance between list elements: 0
  Minimum distance between list elements: 0
  Average distance between list elements: 0

List: []
  Maximum distance between list elements: 0
  Minimum distance between list elements: 0
  Average distance between list elements: 0

List: ["One", "Two", "Three"]
Cannot convert string to number: base-10 number must begin with valid digits or '.' in '⏏Two' (indicated by ⏏)
  in sub max-diff at listdiff.p6 line 3
  in block  at listdiff.p6 line 33
  in block <unit> at listdiff.p6 line 20

REXX

Some basic error checking was made (non─numeric element, not enough elements).

This REXX version was optimized to handle very large lists.

/*REXX program finds/displays the maximum difference between adjacent elements of a list*/
parse arg $                                      /*obtain optional arguments from the CL*/
if $='' | S==","  then $= ,                      /*Not specified?  Then use the default.*/
     '1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3' /*commas are optional;  blanks are OK. */
w= 0                                             /*the maximum width of any element num.*/
$= translate($, , ',')                           /*elide optional commas between numbers*/
#= words($)                                      /*number of elements in the  $  list.  */
             do i=1  for words($); x= word($, i) /*examine each element, ensure a number*/
             @.i= x;     w= max(w, length(x) )   /*assign element #; find maximum width.*/
             if datatype(x, 'N')  then iterate   /*Is it numeric?   Yes, then continue. */
             say '***error***  element #'i    " isn't numeric: "    x
             exit 13
             end   /*i*/
n= 0                                             /*N:   # sets of (difference) elements.*/
if #<2  then do;   say '***error***  not enough elements were specified,  minimum is two.'
                   exit 13
             end
say '   list  of elements: '    space($)         /*show the  list  of  numbers  in list.*/
say '  number of elements: '    #                /*show  "  number  "  elements  "   "  */
d= -1;                                           /*d:  maximum difference found (so far)*/
        do j=1  for #-1;   jp= j + 1;   a= @.j   /*obtain the  "A"  element.            */
                                        b= @.jp  /*   "    "   "B"     "                */
        newD= abs(a - b)                         /*obtain difference between 2 elements.*/
        if newD<d  then iterate                  /*Is this  not  a new max difference ? */
        d= newD                                  /*assign new maximum difference,  and  */
        n= n + 1                                 /*bump the # of (difference) sets.     */
        aa.n= a;        bb.n= b                  /*  the elements that had the max diff.*/
        end   /*j*/
say
say 'The maximum difference of the elements in the list is:  '     d
        do k=1  for n
        say 'and is between the elements: '   right(aa.k, w)    " and "     right(bb.k, w)
        end   /*k*/
exit 0                                           /*stick a fork in it,  we're all done. */

output when using the default input:

   list  of elements:  1 8 2 -3 0 1 1 -2.3 0 5.5 8 6 2 9 11 10 3
  number of elements:  17

The maximum difference of the elements in the list is:   7
and is between the elements:     1  and     8
and is between the elements:     2  and     9
and is between the elements:    10  and     3

Ring

see "working..." + nl
strList = "[1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3]"
see "Maximum difference between adjacent elements of list is:" + nl + nl
see "Input list = " + strList + nl + nl
see "Output:" + nl
sList = [1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3] 
sortList = []

for n = 1 to len(sList)-1
    diff = fabs(sList[n]-sList[n+1])
    oldDiff = diff
    first = sList[n]
    second = sList[n+1]
    add(sortList,[oldDiff,first,second])
next

sortList = sort(sortlist,1)
sortList = reverse(sortlist)
flag = 1

for n=1 to len(sortList)-1
    oldDiff1 = sortlist[n][1]
    oldDiff2 = sortlist[n+1][1] 
    first1 = sortlist[n][2]
    second1 = sortlist[n][3]
    first2 = sortlist[n+1][2]
    second2 = sortlist[n+1][3]
    if n = 1 and oldDiff1 != oldDiff2
       see "" + first1 + "," + second1 + " ==> " + oldDiff1 + nl 
    ok
    if oldDiff1 = oldDiff2
       if flag = 1
          flag = 0
          see "" + first1 + "," + second1 + " ==> " + oldDiff1 + nl   
          see "" + first2 + "," + second2 + " ==> " + oldDiff2 + nl
       else
          see "" + first2 + "," + second2 + " ==> " + oldDiff2 + nl
       ok
    else
       exit
    ok
next

see "done..." + nl

Output:

working...
Maximum difference between adjacent elements of list is:

Input list = [1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3]

Output:
2,9 ==> 7
1,8 ==> 7
10,3 ==> 7
done...

RPL

Works with: Halcyon Calc version 4.2.7

Code

Comments

≪ DUP SIZE 0 → list len max
  ≪ 2 len FOR j
        list j 1 - GET list j GET - ABS
        IF max OVER < THEN 'max' STO 
                            ELSE DROP END
     NEXT 
     {} max +
     2 len FOR j
        list j 1 - GET list j GET
        IF DUP2 - ABS max == THEN R→C + 
                             ELSE DROP2 END
     NEXT
≫ ≫ 'ADJMAX' STO

( {list} -- { max ( adjacent couples) }
Scan input list...
   ... calculate adjacent gap
  ... and store max value


Initialize output list
Scan input list...
    Get 2 adjacent elements
    If gap = max, add the 2 elements as a complex to the output list

The following line of code delivers what is required:

[1 8 2 -3 0 1 1 -2.3 0 5.5 8 6 2 9 11 10 3] ADJMAX

Output:

1: { 7 (1,8) (2,9) (10,3) }

Ruby

list   =   [1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3]

max_dif, pairs =  list.each_cons(2).group_by{|a,b| (a-b).abs}.max

puts "Maximum difference is #{max_dif}:"
pairs.each{|pair| p pair}

Output:

Maximum difference is 7:
[1, 8]
[2, 9]
[10, 3]

Rust

use std::io ;
use itertools::Itertools ;

fn main() {
    println!("Enter some real numbers, separated by blanks!");
    let mut inline : String = String::new( ) ;
    io::stdin( ).read_line( &mut inline ).unwrap( ) ;
    let entered_line : &str = &*inline ;
    let numbers : Vec<f32> = entered_line.split_whitespace( ).map( | s |
          s.trim( ). parse::<f32>( ).unwrap( ) ).collect( ) ;
    let mut pairs : Vec<(&f32, &f32)> = numbers.iter( ).tuple_windows( ).collect( ) ;
    let num_slice = &mut pairs[..] ;
    let len = num_slice.len( ) ;
    num_slice.sort_by( | a, b| (a.0 - a.1).abs( ).partial_cmp(&( &*b.0 -&*b.1).abs( ))
          .unwrap( )) ;
    let maximumpair = &num_slice[len - 1 .. len] ;
    let maxi = maximumpair.to_vec( ) ;
    let maximum : f32 = (maxi[0].0- maxi[0].1).abs( ) ;
    let maxima : Vec<&(&f32, &f32)> = num_slice.iter( ).filter( |&p |
          (p.0 - p.1).abs( ) ==  maximum ).collect( ) ;
    maxima.iter( ).for_each( | p | println!("{},{} ==> {}" ,
             p.0 , p.1 , maximum)) ;
}

Output:

1,8 ==> 7
2,9 ==> 7
10,3 ==> 7

V (Vlang)

Translation of: go

import math

fn main() {
    list := [1.0, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3]
    mut max_diff := -1.0
    mut max_pairs := [][2]f64{}
    for i in 1..list.len {
        diff := math.abs(list[i-1] - list[i])
        if diff > max_diff {
            max_diff = diff
            max_pairs = [[list[i-1], list[i]]!]
        } else if diff == max_diff {
            max_pairs << [list[i-1], list[i]]!
        }
    }
    println("The maximum difference between adjacent pairs of the list is: $max_diff")
    println("The pairs with this difference are: $max_pairs")
}

Output:

The maximum difference between adjacent pairs of the list is: 7
The pairs with this difference are: [[1, 8] [2, 9] [10, 3]]

Wren

var list = [1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8,6, 2, 9, 11, 10, 3]
var maxDiff = -1
var maxPairs = []
for (i in 1...list.count) {
    var diff = (list[i-1] - list[i]).abs
    if (diff > maxDiff) {
        maxDiff = diff
        maxPairs = [[list[i-1], list[i]]]
    } else if (diff == maxDiff) {
        maxPairs.add([list[i-1], list[i]])
    }
}
System.print("The maximum difference between adjacent pairs of the list is: %(maxDiff)")
System.print("The pairs with this difference are: %(maxPairs)")

Output:

The maximum difference between adjacent pairs of the list is: 7
The pairs with this difference are: [[1, 8], [2, 9], [10, 3]]

XPL0

real List, Dist, MaxDist;
int  I;
[List:= [1., 8., 2., -3., 0., 1., 1., -2.3, 0., 5.5, 8., 6., 2., 9., 11., 10., 3.];
MaxDist:= 0.;
for I:= 0 to 17-2 do
    [Dist:= abs(List(I) - List(I+1));
    if Dist > MaxDist then
        MaxDist:= Dist;
    ];
Format(1, 0);
for I:= 0 to 17-2 do
    [Dist:= abs(List(I) - List(I+1));
    if Dist = MaxDist then
        [RlOut(0, List(I));  Text(0, ", ");  RlOut(0, List(I+1));
        Text(0, " ==> ");  RlOut(0, MaxDist);  CrLf(0);
        ];
    ];
]

Output:

1, 8 ==> 7
2, 9 ==> 7
10, 3 ==> 7