Consecutive Distance Rating

Question

We'll call the consecutive distance rating of an integer sequence the sum of the distances between consecutive integers. Consider 2 9 3 6 8 1.

2 9 3 6 8 1
<----5---->
<-2->
 <--3-->

\2ドル\$ and \1ドル\$ are consecutive integers, and their distance apart in the sequence is \5ドル\$.
\2ドル\$ and \3ドル\$ are consecutive integers, and their distance apart in the sequence is \2ドル\$.
\9ドル\$ and \8ドル\$ are consecutive integers, and their distance apart in the sequence is \3ドル\$.
The consecutive distance rating is the sum of these distances: \10ドル\$.

Challenge

Given a possibly empty list of positive, unique integers, find its consecutive distance rating.

Format

You must accept a list of integers and output an integer in any reasonable format.

Rules

• Standard loopholes apply.
• This is code-golf, so the code with the fewest bytes (in each language) wins.

Test cases

[] -> 0
[33] -> 0
[65 57 78 32 81 19 50 24 85 3 97 43 10 73] -> 0
[1 2] -> 1
[2 1] -> 1
[1 2 3] -> 2
[1 3 2] -> 3
[31 63 53 56 96 62 73 25 54 55 64] -> 26
[54 64 52 39 36 98 32 87 95 12 40 79 41 13 53 35 48 42 33 75] -> 67
[94 66 18 57 58 54 93 53 19 16 55 22 51 8 67 20 17 56 21 59] -> 107

• emanresu A: What about something like 3 2 2?
• chunes: @Ausername The input will only consist of unique integers.
• avarice: will the input contain only positive integers?
• Adám: @Wasif "Given a possibly empty list of positive, unique integers, find its consecutive distance rating." [my emphasis]
• chunes: @Shaggy I'm going to say no, because the output format has been an integer from the beginning, and other languages may have had to compromise in bytes to satisfy that requirement.

Answer 1

Python 2, 60 bytes

lambda l:sum(abs(l.index(x)-l.index(x+(x+1in l)))for x in l)

Try it online!

• ovs: There is a way of saving a few bytes by getting rid of the if ...
• xnor: @ovs Ah, right, nice one
• user100690: 1 in -> 1in

Answer 2

Jelly, 8 bytes

iⱮ‘aạ\JS

Try it online!

-1 byte thanks to Unrelated String!

How it Works

iⱮ‘aạ\JS - Main link. Takes a list L on the left
 ‘ - Increment all elements in L
 Ɱ - Over each incremented element:
i - Get its 1-based index in L, or 0 if not present
 Call this list of indices I
 J - Indices of L; [1, 2, 3, ..., len(L)]
 \ - Last 2 links as a dyad f(I, J):
 ạ - Absolute difference, element wise, between I and J
 a - And; Where there are non-zeroes in I, replace the value with corresponding difference
 S - Sum

• Unrelated String: As much as I love to look at the aaạ, I'm not sure you need the triple dyad there, seeing as IaJ has the same pattern of zero/nonzero as I. (Funny bonus 8-byter: iⱮ‘oJạJS)
• caird coinheringaahing: @UnrelatedString Aww, now I have to redo my whole explanation :P

Answer 3

J, 22 bytes

[:+/&,|@(#\-/#\)*1=-/~

Try it online!

Consider f 2 9 3 6 8 1:

• -/~ Table of differences:

  0 _7 _1 _4 _6 1
  7 0 6 3 1 8
  1 _6 0 _3 _5 2
  4 _3 3 0 _2 5
  6 _1 5 2 0 7
  _1 _8 _2 _5 _7 0
  

• 1= Where are they 1?

  0 0 0 0 0 1
  0 0 0 0 1 0
  1 0 0 0 0 0
  0 0 0 0 0 0
  0 0 0 0 0 0
  0 0 0 0 0 0
  

• |@(#\-/#\) Table of absolute value of index differences:

  0 1 2 3 4 5
  1 0 1 2 3 4
  2 1 0 1 2 3
  3 2 1 0 1 2
  4 3 2 1 0 1
  5 4 3 2 1 0
  

• * Elementwise product of those tables:

  0 0 0 0 0 5
  0 0 0 0 3 0
  2 0 0 0 0 0
  0 0 0 0 0 0
  0 0 0 0 0 0
  0 0 0 0 0 0
  

• [:+/&, Sum of that table flattened:

  10
  

Answer 4

05AB1E, 8 bytes

ãʒÆ}kÆÄO

Try it online!

ã # all pairs of integers from the input
 ʒ } # keep those where the following results in 1:
 Æ # reduce by subtraction
 k # for each integer in each pair get the index in the input list
 Æ # reduce each pair of indices by subtraction
 Ä # take absolute value
 O # sum all distances

Answer 5

R, 47 bytes

sum(abs(seq(a<-scan())-(b=match(a+1,a,0)))*!!b)

Try it online! with test wrapper stolen from pajonk's answer stolen from Kirill L's answer

• pajonk: The test wrapper is actually by @Kirill ;-)
• pajonk: Then why not merge our solutions? 45 bytes

Answer 6

R, 45 bytes

sum(abs(seq(a<-scan())-match(a+1,a)),na.rm=T)

Try it online!

Merged solutions: mine and @Dominic's.

---

Previous solution:

R, 48 bytes

x=scan();`*`=match;sum(abs(x*x-(x+1)*x),na.rm=T)

Try it online!

• Kirill L.: This can be 48 as a full program, making it the same length as my answer. However, now when there's \(x) syntax in R 4.1, but not available on TIO, I'm not sure anymore, which format to prefer...
• pajonk: @Kirill I'll change it to the scan version, so the answers are comparable. Which format to prefer? I mainly post functions because I think it's easier to read that way and I mostly care about the internal algorithm not the wrapper or technicalities.
• Dominic van Essen: I couldn't resist joining the competition...

Answer 7

JavaScript (Node.js), 60 bytes

n=>n.map((e,i)=>z+=(j=n.indexOf(e+1))+1?j>i?j-i:i-j:0,z=0)|z

Try it online!

• Arnauld: (j=n.indexOf(e+1))+1 ~> ~(j=n.indexOf(e+1))
• Neil: (j=n.indexOf(e+1))<i?~j&&i-j:j-i is better still.

Answer 8

Red, (削除) 88 (削除ここまで) 77 bytes

func[b][s: 0 forall b[s: s + absolute offset? b any[find head b 1 + b/1 b]]s]

Try it online!

Uses @xnor's method - don't forget to upvote it!

• Razetime: Is the /: an assign at index?
• Galen Ivanov: @Razetime No, it's just indexing using the word (think variable) i. You can't just use b/i because it would mean select b 'i and the block b doesn't have a word i inside itself.
• Galen Ivanov: @Razetime Assign at index is b/1: value. If the index is referred to by a word idx, we need to write b/:idx: value.

Answer 9

Ruby, (削除) 50 (削除ここまで) 48 bytes

->a{r=-1;a.sum{((a.index(a[r+=1]+1)||r)-r).abs}}

Try it online!

Thanks @ovs for -2 bytes.

Answer 10

Charcoal, 15 bytes

I↨1Eθ↔↨1−⌕Aθ⊕ικ

Try it online! Link is to verbose version of code. Explanation:

 θ Input array
 E Map over elements
 ι Current value
 ⊕ Incremented
 ⌕A Find all (i.e. at most one) matches
 θ In input array
 − Vectorised subtract
 κ Current index
 ↨1 Take the sum
 ↔ Take the absolute value
 ↨1 Take the sum
I Cast to string
 Implicitly print

Note that base 1 conversion is used to sum as this works on empty lists.

Answer 11

R, 48 bytes

`?`=diff;sum(abs(?o<-order(x<-scan()))*!1<?x[o])

Try it online!

• pajonk: Wow, that's impressive! Great use of order!

Answer 12

Vyxal s, 13 bytes

›vḟv›ƛ&›[\ε|0

Try it Online!

A port of the jelly answer, and I think the best I'm gonna get.

Attempted port of Jonas, 21 bytes

Ẋƛ÷ε1=;?Lɾƛ?Lɾ-ȧ;f*∑1⁄2

Try it Online!

Old version, 23 bytes

L2(0Ẋni÷ε1=[n6ḋ÷ε&+])1円⁄2

Try it Online! I still think there's a bit more I can do.

Older version, 28 bytes

L(x|L(←x i0niε1=[n←xε&+]))1円⁄2

Try it Online!

This. Is. Horrible.

• lyxal: Porting jelly somehow could save bytes

Answer 13

MATL, 9 bytes

tQ!=&f-|s

Try it online! Or verify all test cases.

How it works

Consider input [2 9 3 6 8 1] as an example.

tQ % Implicit input. Duplicate, add 1; element-wise
 % STACK: [2 9 3 6 8 1], [3 10 4 7 9 2]
! % Transpose
 % STACK: [2 9 3 6 8 1], [3; 10; 4; 7; 9; 2]
= % Test for equality (element-wise with broadcast)
 % STACK: [0 0 1 0 0 0;
 0 0 0 0 0 0;
 0 0 0 0 0 0;
 0 0 0 0 0 0;
 0 1 0 0 0 0;
 1 0 0 0 0 0]
&f % Two-output find: row and column indices of nonzeros
 % STACK: [6; 5; 1], [1; 2; 3]
-| % Minus, absolute value (element-wise)
 % STACK: [5; 3; 2]
s % Sum. Implicit display
 % STACK: 10

Answer 14

Brachylog, 15 bytes

sf{↻h2-ȧ1&b}scl

Try it online!

sf Find every substring of the input.
 { }s Keep only those for which
 ȧ the absolute value of
 - the difference of
 ↻h2 the first and last elements
 1 is 1,
 &b and remove their first elements.
 c Concatenate them,
 l and output their combined length.

Answer 15

Japt -mx, (削除) 16 (削除ここまで) (削除) 11 (削除ここまで) 10 bytes

Inspired by xnor's solution.

VaWbU+WøUÄ

Try it

VaWbU+WøUÄ :Implicit map of each U at 0-based index V in input array W
Va :Absolute difference of V and
 Wb : Index in W of
 U+Wø : U + Does W contain
 UÄ : U+1
 :Implicit output of sum of resulting array

Answer 16

Julia 1.0, (削除) 63 (削除ここまで) 55 bytes

Inspired by the answer of xnor

Improved version, thanks @MarcMush:

!x=sum(abs,[(I=indexin)(i,x)-I(i+(i+1∈x),x) for i=x])

Try it online!

First version:

!x=sum(abs.([indexin(i,x)-indexin(i+(i+1 in x),x) for i in x]))

Try it online!

• MarcMush: 56 bytes
• MarcMush: -2 bytes by using * instead of I Try it online!

Answer 17

Python 3, 91 bytes

def f(l):c=sorted(l);return sum(abs(l.index(x)-l.index(y))for x,y in zip(c,c[1:])if y-x==1)

Try it online!

• user100690: -1 by switching to Python 3.8.

Answer 18

Red, 129 bytes

func[a][s: 0
b: sort copy a
while[b/2][s: s + either b/2 - b/1 = 1[absolute(index? find a b/2)- index? find a b/1][0]b: next b]s]

Try it online!

sorts the array, and adds the index difference to s if pair of elements has an absolute difference of 1.

Not sure how to shorten the reuse of index? find, but I think it can be shortened. abs alias for absolute is not available, even in version 0.6.4.

Answer 19

Excel, 52 bytes

=LET(x,A:A,SUM(IFERROR(ABS(ROW(x)-XMATCH(x-1,x)),)))

Input numbers in column A. For each number x in column A look for x-1. If found add the difference in rows between x and x-1.

Answer 20

Japt -x, (削除) 20 17 (削除ここまで) 12 bytes

ã_ÎaZo)1円©ZÊ

Try it

• saved 5 thanks to @Shaggy!

 ã_ - subsections passed trough
 ÎaZo) * abs difference of 1st
 and last element(then removed)
 1円 * == 1?
 ©ZÊ * take lenght/else 0
 -x flag to sum

• Shaggy: 15 bytes, or 14 bytes with the -x flag.
• Shaggy: 13 bytes
• Shaggy: 12 bytes; always forget A.ã() can take a function. I hate that I've just outgolfed myself!
• AZTECCO: @Shaggy great! Didn't notice A.o removed the element, that's why it gave me wrong result!
• Shaggy: A.o(), without an argument, is the same as .pop() in JS.

Answer 21

Wolfram Language (Mathematica), 42 bytes

Tr@Abs[s@@@Outer[s=#-#2&,#,#]~Position~1]&

Try it online!

Essentially a port of Jonah's J answer.

Answer 22

JavaScript (V8), 54 bytes

$=([o,...a])=>o?a.indexOf(o+1)+a.indexOf(o-1)+2+$(a):0

Try it online!

Answer 23

Thunno, \$ 24 \log_{256}(96) \approx \$ 19.75 bytes

2zPgAu-1=keez0AhEeAuADES

Attempt This Online!

Explanation

2zP # All pairs in the input
 g # Filtered by:
 Au- # Does the difference
 1= # Equal 1?
k # End filter
 e # Map over the list:
 e # Map over the pair
 z0Ah # Get the index in the input
 E # End both maps
e # Map over this list:
 AuAD # Get the absolute difference
 E # End map
 S # Sum this list
 # Implicit output

Answer 24

Octave, 54 bytes

@(a){[x j]=sort(a)
sum(abs(j(d=diff(x)<2)-j([!1 d])))}

Try it online!

My idea was to sum the absolute values of the differences of ordering indices of the elements while filtering away the lone elements (there is a possible similarity to one R answer, but I haven't check it in details).

• [x j]=sort(a) outputs the sorted array x along with the ordering indices j;
• diff(x)<2 condition (==1) for the consecutive adjacent numbers;
• j(diff(x)<2) and j([false diff(x)<2)] this subsetting allows to find and match the pairs;
• abs and sum is trivial.

Answer 25

Nibbles, (削除) 17 (削除ここまで) 16 nibbles ((削除) 8.5 (削除ここまで) 8 bytes)

+.$??@+$~!=$?_@-

Attempt This Online! Corresponds to the 8 bytes 8c 3f f4 83 0c 03 f5 49. -0.5 bytes thanks to @Dominic van Essen, for observing that the if/else ? saves the value used for the conditional as additional context, allowing me to use my longer solution while avoiding the explicit save!

Previous 8.5 byte solution: +.$*!=?@$;?@+$~`$.

Explanation

This is similar in execution to @caird coinheringaahin g's 8-byte Jelly answer.

+.$??@+$~!=$?_@-
+.$??@+$~!=$?_@-$$ # (with implicit argument)
 .$ # map over each element X in the input:
 +$~ # compute X+1
 ?@ # and its index in the original list
 ? # if it is positive (aka found):
 # then that value is saved in $
 != # so we take the absolute difference of...
 $ # that saved index
 ?_@ # and the index of X in the original list
 -$$ # otherwise, return X-X, aka 0

Old Explanation

+.$*!=?@$;?@+$~`$
+.$*!=?@$;?@+$~`$$ # (with implicit argument)
 .$ # map over each element X in the input:
 != # absolute difference of...
 ? # ...index of
 +$~ # X+1
 @ # in the original list input
 ; # (save this index for later)
 ?@$ # ..and the current index (1-based)
 * # multiplied by
 `$ # the sign of
 $ # the index of X+1 we saved (which is 0 when not found)
+ # sum resulting list

• Dominic van Essen: Nice! Your 9.5 byter can be reduced to 8 bytes by leaving-out the save (;), which isn't used, letting you change ;$_ to _@ (by moving up one DeBruijn index), and swapping the final 0 to - (meaning -$$ which is always zero)...
• Conor O'Brien: @DominicvanEssen Wow! Those are cool observations, I coulda sworn I used the save lol. Thanks!!

Answer 26

Uiua, 12 bytes

/+⌵/-⍉⊚=1⊞-.

Try it!

/+⌵/-⍉⊚=1⊞-.
 ⊞-. # difference table
 ⊚=1 # coordinates of ones
 ⍉ # transpose
 ⌵/- # absolute difference of columns
/+ # sum

Answer 27

Scala 3, 122 bytes

Golfed version. Attempt This Online!

l=>l.flatMap(x=>l.indexOf(x+(if(l.contains(x+1))1 else 0))match{case -1=>None;case i=>Some(Math.abs(l.indexOf(x)-i))}).sum

Ungolfed version. Attempt This Online!

def calculate(list: List[Int]): Int = {
 list
 .flatMap(x =>
 list.indexOf(x + (if (list.contains(x + 1)) 1 else 0)) match {
 case -1 => None
 case i => Some(Math.abs(list.indexOf(x) - i))
 }
 )
 .sum
}