Maximum difference between adjacent elements of list: Difference between revisions
Maximum difference between adjacent elements of list (view source)
Revision as of 13:59, 4 April 2024
, 2 months agono edit summary
(Maximum difference between adjacent elements of list in FreeBASIC) |
No edit summary |
||
| (18 intermediate revisions by 15 users not shown) | |||
Line 18:
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">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]
Line 27 ⟶ 26:
L(ab) maxPairs
print(ab)</
{{out}}
Line 39 ⟶ 38:
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<
DEFINE PTR="CARD"
Line 121 ⟶ 120:
Test("0.12 -0.04 0.34 0.72 0.34 0.27 -0.1")
Test("10E30 20E30 15E30 5E30 -5E30")
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Maximum_difference_between_adjacent_elements_of_list.png Screenshot from Atari 8-bit computer]
Line 139 ⟶ 138:
AbsDiff(1.5E+31, 5E+30) = 1.0E+31
AbsDiff(5E+30, -5E+30) = 1.0E+31
</pre>
=={{header|Ada}}==
<syntaxhighlight lang="algol68">
-- 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;
</syntaxhighlight>
{{out}}
<pre>
1,8 ==> 7
2,9 ==> 7
10,3 ==> 7
</pre>
=={{header|ALGOL 68}}==
<
# returns the maximum difference between pairs of elements of list #
OP MAXDELTA = ( []REAL list )REAL:
Line 197 ⟶ 245:
test max delta( ( -1.1, -1.2 ) ); test max delta( ( pi, pi, pi ) );
test max delta( ( ) ); test max delta( ( 776.591 ) )
END</
{{out}}
<pre>
Line 214 ⟶ 262:
=={{header|ALGOL W}}==
<
% returns the maximum difference between pairs of elements of list %
% the lower and upper bounds of list must be specified in lb & ub %
Line 271 ⟶ 319:
testMaxDelta( tc, 1, 1, 6, 3 )
end
end.</
{{out}}
<pre>
Line 289 ⟶ 337:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
{{out}}
<pre> maxdiff 1 8 2 ¯3 0 1 1 ¯2.3 0 5.5 8 6 2 9 11 10 3
Line 295 ⟶ 343:
7 2 9
7 10 3</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="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]</syntaxhighlight>
{{out}}
<pre>[1 8] -> 7
[2 9] -> 7
[10 3] -> 7</pre>
=={{header|AutoHotkey}}==
<
mxDiff := []
Line 303 ⟶ 380:
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")</
{{out}}
<pre>1, 8 ==> 7
Line 310 ⟶ 387:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f MAXIMUM_DIFFERENCE_BETWEEN_ADJACENT_ELEMENTS_OF_LIST.AWK
BEGIN {
Line 330 ⟶ 407:
}
function abs(x) { if (x >= 0) { return x } else { return -x } }
</syntaxhighlight>
{{out}}
<pre>
7: 1,8 2,9 10,3
</pre>
=={{header|BASIC}}==
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">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.</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">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</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|Yabasic}}===
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
=={{header|C}}==
{{trans|Wren}}
<syntaxhighlight lang="c">#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;
}</syntaxhighlight>
{{out}}
<pre>
The maximum difference between adjacent pairs of the list is: 7
The pairs with this difference are: [1, 8] [2, 9] [10, 3]
</pre>
=={{header|C++}}==
<syntaxhighlight lang="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 ;
}</syntaxhighlight>
{{out}}
<pre>
1,8 ==> 7
2,9 ==> 7
10,3 ==> 7
</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
{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;
</syntaxhighlight>
{{out}}
<pre>
abs( 1.0 - 8.0) = 7.0
abs( 2.0 - 9.0) = 7.0
abs(10.0 - 3.0) = 7.0
</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
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
.
.
</syntaxhighlight>
{{out}}
<pre>
1,8 ==> 7
2,9 ==> 7
10,3 ==> 7
</pre>
=={{header|F_Sharp|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
</syntaxhighlight>
{{out}}
<pre>
Line 348 ⟶ 663:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<
: 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 .</
{{out}}
<pre>
Line 361 ⟶ 676:
=={{header|Free Pascal}}==
{{trans|Pascal}}
<
program maximumDifferenceBetweenAdjacentElementsOfList(output);
type
Line 412 ⟶ 727:
readln;
{$ENDIF}
end.</
{{out}}
<pre>
Line 418 ⟶ 733:
idx : 12 values 2.0000000000000000E+000 9.0000000000000000E+000
idx : 15 values 1.0000000000000000E+001 3.0000000000000000E+000 </pre>
=={{header|FreeBASIC}}==
<
Dim As Single List(16) => {1., 8., 2., -3., 0., 1., 1., -2.3, 0., 5.5, 8., 6., 2., 9., 11., 10., 3.}
Line 433 ⟶ 747:
Dist = Abs(List(i) - List(i+1))
If Dist = MaxDist Then Print List(i) & ", " & List(i+1) & " ==> " & MaxDist
Next i</
{{out}}
<pre>Maximum difference between adjacent elements of lista is:
1, 8 ==> 7
2, 9 ==> 7
10, 3 ==> 7</pre>
=={{header|Go}}==
<
import (
Line 459 ⟶ 777:
fmt.Println("The maximum difference between adjacent pairs of the list is:", maxDiff)
fmt.Println("The pairs with this difference are:", maxPairs)
}</
{{out}}
Line 468 ⟶ 786:
=={{header|Haskell}}==
<
import Data.Ord (comparing)
Line 484 ⟶ 802:
main =
mapM_ print $
maxDeltas [1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3]</
{{Out}}
<pre>(7.0,(1.0,8.0))
Line 491 ⟶ 809:
=={{header|J}}==
<
{{out}}
<pre> maxdiff 1 8 2 _3 0 1 1 _2.3 0 5.5 8 6 2 9 11 10 3
(}:,&":' ==> ',&":{:)"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</pre>
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<
. as $in
| reduce range(1; length) as $i ({ maxDiff: -1};
Line 518 ⟶ 839:
[1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8,6, 2, 9, 11, 10, 3]
| maximally_different_adjacent_pairs
</syntaxhighlight>
{{out}}
<pre>
Line 525 ⟶ 846:
=={{header|Julia}}==
<
function maxadjacentdiffs(list)
pairs, maxδ = Pair{eltype(list)}[], abs(zero(eltype(list)))
Line 539 ⟶ 860:
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)
</
<pre>
1
2
10
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
diff = Abs@Differences[l];
m = Max[diff];
pos = Flatten[Position[diff, m]];
Column[Part[l, # ;; # + 1] -> m & /@ pos]</
{{out}}
<pre>{1,8}->7
Line 561 ⟶ 882:
=={{header|Nim}}==
<
type Pair = (float, float)
Line 584 ⟶ 905:
echo &"The maximum difference between adjacent pairs of the list is: {diff:g}"
echo "The pairs with this difference are: ", pairs.join(" ")</
{{out}}
<pre>The maximum difference between adjacent pairs of the list is: 7
The pairs with this difference are: (1, 8) (2, 9) (10, 3)</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>7: (1, 8) (2, 9) (10, 3)</pre>
=={{header|Pascal}}==
The following <tt>program</tt> needs an ISO 7185 Standard “unextended” Pascal, level 1, compliant compiler.
<
function internalDistance(
Line 621 ⟶ 964:
list[1] := 1.0; list[2] := 8.0;
writeLn(internalDistance(list));
end.</
=={{header|Perl}}==
<
use strict;
Line 635 ⟶ 978:
reduce { $diffs{ abs $a - $b } .= " $a,$b"; $b } @list;
my $max = max keys %diffs;
print "$_ ==> $max\n" for split ' ', $diffs{ $max };</
{{out}}
<pre>
Line 644 ⟶ 987:
=={{header|Phix}}==
<!--<
<span style="color: #008080;">procedure</span> <span style="color: #000000;">differences</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">mx</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">},</span> <span style="color: #000000;">mn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">mx</span>
Line 672 ⟶ 1,015:
<span style="color: #000000;">differences</span><span style="color: #0000FF;">({})</span>
<span style="color: #000000;">differences</span><span style="color: #0000FF;">({</span><span style="color: #000000;">776.591</span><span style="color: #0000FF;">})</span>
<!--</
{{output}}
<pre>
Line 695 ⟶ 1,038:
avg difference is 0
</pre>
=={{header|Picat}}==
<syntaxhighlight lang="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.</syntaxhighlight>
{{out}}
<pre>7 = [[1,8],[2,9],[10,3]]</pre>
Here is an alternative way to get the pairwise differences, using <code>zip/2</code>:
<syntaxhighlight lang="picat"> % ...
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].</syntaxhighlight>
=={{header|Python}}==
<
Line 733 ⟶ 1,098:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>(7, (1, 8))
Line 740 ⟶ 1,105:
=={{header|Raku}}==
<syntaxhighlight lang="raku" line>sub max-diff (*@list) {
return 0 if +@list < 2;
my $max = @list.rotor(2 => -1).max({ (.[0] - .[1]).abs }).map( (* - *).abs )[0];
Line 776 ⟶ 1,140:
}
say '';
}</
{{out}}
<pre>List: [1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3]
Line 819 ⟶ 1,183:
This REXX version was optimized to handle very large lists.
<
parse arg $ /*obtain optional arguments from the CL*/
if $='' | S=="," then $= , /*Not specified? Then use the default.*/
Line 852 ⟶ 1,216:
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. */</
{{out|output|text= when using the default input:}}
<pre>
Line 865 ⟶ 1,229:
=={{header|Ring}}==
<
see "working..." + nl
strList = "[1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3]"
Line 910 ⟶ 1,274:
see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
Line 925 ⟶ 1,289:
</pre>
=={{header|
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! 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
{{out}}
<pre>
1: { 7 (1,8) (2,9) (10,3) }
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="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}
</syntaxhighlight>
{{out}}
<pre>Maximum difference is 7:
[1, 8]
[2, 9]
[10, 3]
</pre>
=={{header|Rust}}==
<syntaxhighlight lang="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)) ;
}</syntaxhighlight>
{{out}}
<pre>
1,8 ==> 7
2,9 ==> 7
10,3 ==> 7
</pre>
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">import math
fn main() {
Line 944 ⟶ 1,397:
println("The maximum difference between adjacent pairs of the list is: $max_diff")
println("The pairs with this difference are: $max_pairs")
}</
{{out}}
Line 953 ⟶ 1,406:
=={{header|Wren}}==
<
var maxDiff = -1
var maxPairs = []
Line 966 ⟶ 1,419:
}
System.print("The maximum difference between adjacent pairs of the list is: %(maxDiff)")
System.print("The pairs with this difference are: %(maxPairs)")</
{{out}}
Line 975 ⟶ 1,428:
=={{header|XPL0}}==
<
int I;
[List:= [1., 8., 2., -3., 0., 1., 1., -2.3, 0., 5.5, 8., 6., 2., 9., 11., 10., 3.];
Line 992 ⟶ 1,445:
];
];
]</
{{out}}
| |||