40
\$\begingroup\$

An insignificant array is an array of positive integers, where the absolute differences between consecutive elements are all smaller than or equal to 1.

For example, the following array is insignificant:

[1, 2, 3, 4, 3, 4, 5, 5, 5, 4]

Because the corresponding (absolute) differences are:

[1, 1, 1, 1, 1, 1, 0, 0, 1]

Which are all smaller than or equal to 1.


Your task is to determine whether a given array of integers is insignificant.

  • You may assume that the array always contains at least two elements.
  • Standard input and output rules apply. You may take input (and output) in any reasonable format.
  • Default Loopholes are forbidden.
  • The truthy / falsy values have to be distinct and consistent.
  • This is , so shortest answer in bytes wins.

Test cases

Input -> Output

[1, 2, 3, 4, 3, 4, 5, 5, 5, 4] -> true
[1, 2, 3, 4, 5, 6, 7, 8, 9, 8] -> true
[3, 3, 3, 3, 3, 3, 3]          -> true
[3, 4, 4, 4, 3, 3, 3, 4, 4, 4] -> true
[1, 2, 3, 4]                   -> true 
[5, 4, 3, 2]                   -> true 
[1, 3, 5, 7, 9, 7, 5, 3, 1]    -> false
[1, 1, 1, 2, 3, 4, 5, 6, 19]   -> false
[3, 4, 5, 6, 7, 8, 7, 5]       -> false
[1, 2, 4, 10, 18, 10, 100]     -> false
[10, 20, 30, 30, 30]           -> false

I used the values true and false.

\$\endgroup\$
  • \$\begingroup\$ Do the truthy/falsy values actually have to be truthy/falsy in our language of choice, or can we use any two distinct and consistent values? \$\endgroup\$ – Martin Ender Sep 20 '17 at 17:36
  • 1
    \$\begingroup\$ @MartinEnder Any two distinct and consistent values. P.S Sorry for the late response \$\endgroup\$ – user70974 Sep 20 '17 at 18:04
  • 2
    \$\begingroup\$ The text says you'll be given an array of integers, but that only arrays of positive integers can be insignificant. Should we be prepared for an array of negative integers? \$\endgroup\$ – Mark S. Sep 23 '17 at 12:50

48 Answers 48

24
\$\begingroup\$

Jelly, 3 bytes

IỊẠ

Try it online!

How?

Just the perfect challenge for Jelly.

IỊẠ   Full program.

I     Increments; Get the difference between consecutive elements.
 Ị    Insignificant; return abs(number) ≤ 1.
  Ạ   All; returns 1 if all the elements are truthy, 0 otherwise.
\$\endgroup\$
  • 2
    \$\begingroup\$ P wouldn't work would it, because if all the differences were 1 it'd output 1, but if one of them was 0 it would output 0? And if one difference was 5 but one was 0 it would still do 0? \$\endgroup\$ – Tas Sep 22 '17 at 3:59
  • 1
    \$\begingroup\$ What about the "positive integers" requirement? \$\endgroup\$ – 3D1T0R Sep 23 '17 at 3:06
19
\$\begingroup\$

JavaScript (ES7), 33 29 bytes

Saved 4 bytes thanks to @JohanKarlsson

a=>!a.some(v=>(a-(a=v))**2>1)

How?

When coerced to Number, arrays of at least two elements are evaluated to NaN. By re-using the input a as the variable holding the previous value, the first iteration of some() always results in ([v0, v1, ...] - a[0]) ** 2 = NaN, no matter the value of a[0]. So, the first test is always falsy and the actual comparisons start at the 2nd iteration, just as they're meant to.

Test cases

let f =

(a,p)=>!a.some(v=>(p-(p=v))**2>1)

console.log(f([1, 2, 3, 4, 3, 4, 5, 5, 5, 4])) // true
console.log(f([1, 2, 3, 4, 5, 6, 7, 8, 9, 8])) // true
console.log(f([3, 3, 3, 3, 3, 3, 3]         )) // true
console.log(f([3, 4, 4, 4, 3, 3, 3, 4, 4, 4])) // true
console.log(f([1, 2, 3, 4]                  )) // true
console.log(f([5, 4, 3, 2]                  )) // true
console.log(f([1, 3, 5, 7, 9, 7, 5, 3, 1]   )) // false
console.log(f([1, 1, 1, 2, 3, 4, 5, 6, 19]  )) // false
console.log(f([3, 4, 5, 6, 7, 8, 7, 5]      )) // false
console.log(f([1, 2, 4, 10, 18, 10, 100]    )) // false
console.log(f([10, 20, 30, 30, 30]          )) // false

\$\endgroup\$
  • \$\begingroup\$ 29 bytes: a=>!a.some(v=>(a-(a=v))**2>1) \$\endgroup\$ – Johan Karlsson Sep 22 '17 at 8:45
  • \$\begingroup\$ @JohanKarlsson Ah yes, the input is guaranteed to contain at least 2 elements, so that's safe. Thanks a lot! \$\endgroup\$ – Arnauld Sep 22 '17 at 11:47
11
\$\begingroup\$

Python 3, 40 bytes

f=lambda n,*t:t==()or-2<n-t[0]<=1==f(*t)

Try it online!

\$\endgroup\$
7
\$\begingroup\$

Mathematica, 24 bytes

Max@Abs@Differences@#<2&
\$\endgroup\$
  • \$\begingroup\$ #==Clip@#&@*Differences is one byte shorter. \$\endgroup\$ – Misha Lavrov Nov 3 '17 at 23:57
7
\$\begingroup\$

Python 2, 35 bytes

x=input()
while-2<x.pop(0)-x[0]<2:1

Exists with status code 1 for insignificant arrays, with status code 0 otherwise.

Try it online!

\$\endgroup\$
6
\$\begingroup\$

Husk, 4 bytes

ΛεẊ-

Try it online!

Explanation:

ΛεẊ- 2-function composition
Λ    (x -> y):f -> [x]:x -> TNum: Check if f returns a truthy result for all elements of x
 ε    f: TNum:x -> TNum: Check if abs(x) <= 1 (shamelessly stolen from Jelly)
  Ẋ   x: (x -> x -> y):f -> [x]:x -> [y]: reduce each overlapping pair of x by f
   -   f: TNum:x -> TNum:y -> TNum: y - x
\$\endgroup\$
6
\$\begingroup\$

Octave, 21 bytes

@(x)all(diff(x).^2<2)

Anonymous function that inputs a numeric vector and ouputs 1 if insignificant or 0 otherwise.

Try it online!

\$\endgroup\$
6
\$\begingroup\$

Haskell, 34 33 bytes

all((<2).abs).(zipWith(-)=<<tail)

Try it online! -1 byte thanks to @user1472751


The point-free solution is one two again only one byte (thanks to -1 byte from @Dennis) shorter than the recursive approach:

f(a:b:r)=2>(a-b)^2&&f(b:r)
f _=1>0

Try it online!

\$\endgroup\$
5
\$\begingroup\$

Pyth, 6 bytes

._MI.+

Verify all the test cases.


Pyth, 8 bytes

.A<R2aVt

Try it online!

Explanation

._MI.+   Full program.

    .+   Deltas.
   I     Is invariant under...
._M      Mapping with Sign. 0 if n == 0, -1 if n < 0, 1 if n > 0.

.A<R2aVt    Full program.

      Vt    Vectorize function, applied on the input zipped with the tail of the input.
     a      Absolute difference.
  <R2       For each, check if it is smaller than 2.
.A          All.
\$\endgroup\$
  • \$\begingroup\$ I have no idea why I thought I# instead of M. \$\endgroup\$ – Steven H. Sep 20 '17 at 18:48
5
\$\begingroup\$

Proton, 41 bytes

a=>all(-2<a[i]-a[i+1]<2for i:0..len(a)-1)

Try it online!

-16 bytes thanks to Mr. Xcoder
-2 bytes
-6 bytes thanks to Mr. Xcoder

\$\endgroup\$
  • \$\begingroup\$ 49 bytes (-16 bytes) \$\endgroup\$ – Mr. Xcoder Sep 20 '17 at 16:06
  • \$\begingroup\$ @Mr.Xcoder I think the space in <2 for might be omittable. \$\endgroup\$ – Jonathan Frech Sep 20 '17 at 16:08
  • \$\begingroup\$ @JonathanFrech There is no space there? \$\endgroup\$ – Mr. Xcoder Sep 20 '17 at 16:08
  • \$\begingroup\$ @Mr.Xcoder oh yeah I don't know what I was thinking with all those crazy function chainings. Thanks! :D \$\endgroup\$ – HyperNeutrino Sep 20 '17 at 16:24
5
\$\begingroup\$

Japt, 6 bytes

äa e<2

Try it online!

Explanation

ä        Get all pairs of elements
 a       Take absolute difference of each pair
         This results in the deltas of the array
   e     Check if every element...
    <2   Is less than 2
\$\endgroup\$
5
\$\begingroup\$

C# (.NET Core), 51 45 44 + 18 bytes

-1 byte thanks to Jeppe Stig Nielsen

a=>a.Zip(a.Skip(1),(x,y)=>x-y).All(x=>x*x<4)

Byte count also includes:

using System.Linq;

Try it online!

Explanation:

a =>                      // Take an array of integers as input
    a.Zip(                // Combine each element with corresponding one from:
        a.Skip(1),        //     the input array without first element
        (x, y) => x - y   //     get their difference
    )
    .All(x => x * x < 4)  // Check if all differences are less than 2
                          // (We only care about 0 and 1, and so happens that when they're squared, it works like Abs! Magic!)
\$\endgroup\$
  • 3
    \$\begingroup\$ Little improvement: a=>a.Zip(a.Skip(1),(x,y)=>x-y).All(x=>x*x<4), it avoids the negation !. \$\endgroup\$ – Jeppe Stig Nielsen Sep 20 '17 at 19:42
  • \$\begingroup\$ @JeppeStigNielsen awesome, thank you! \$\endgroup\$ – Grzegorz Puławski Sep 20 '17 at 19:48
5
\$\begingroup\$

Perl 6, 25 bytes

{?(2>all(.[]Z-.skip)>-2)}

Try it online!

This should be pretty readable. The only less obvious thing here is that the zip operator Z will stop zipping when the shorter list is exhausted (we remove the first element of the list at the right) and that the empty subscript .[], so called Zen slice, gives the whole list. .skip returns the list without the first element.

\$\endgroup\$
  • \$\begingroup\$ Are those two spaces really necessary? \$\endgroup\$ – Jonathan Frech Sep 20 '17 at 15:52
  • \$\begingroup\$ @JonathanFrech: The right one probably no. Also I just realized that the .rotate is not needed here. \$\endgroup\$ – Ramillies Sep 20 '17 at 15:53
  • \$\begingroup\$ Heck, even the left one could be removed. I really don't understand where the whitespace is required and where it is not... \$\endgroup\$ – Ramillies Sep 20 '17 at 15:54
  • \$\begingroup\$ You could write -2< instead of -1≤ and <2 instead of ≤1 to save four more bytes. \$\endgroup\$ – Sean Sep 20 '17 at 17:18
  • \$\begingroup\$ Er, I guess you actually have to reverse the comparisons 2>...>-2 to avoid interpreting the < in an erroneous way. \$\endgroup\$ – Sean Sep 20 '17 at 17:21
5
\$\begingroup\$

R, 30 26 bytes

cat(all(diff(scan())^2<2))

Try it online!

\$\endgroup\$
  • 3
    \$\begingroup\$ I think function(a)all(diff(a)^2<2) saves 3 bytes. \$\endgroup\$ – BLT Sep 20 '17 at 18:34
  • \$\begingroup\$ you could take the input from the console: all(diff(scan())^2<2) \$\endgroup\$ – flodel Sep 21 '17 at 1:51
  • \$\begingroup\$ @BLT good point! \$\endgroup\$ – user2390246 Sep 21 '17 at 8:05
  • 1
    \$\begingroup\$ @flodel There was some recent discussion regarding the need to explicitly print the output when using scan, but it still saves a byte! \$\endgroup\$ – user2390246 Sep 21 '17 at 8:11
4
\$\begingroup\$

05AB1E, 5 bytes

¥Ä2‹P

Try it online!

Explanation

¥        # calculate deltas
 Ä       # absolute values
  2‹     # smaller than 2
    P    # product
\$\endgroup\$
  • \$\begingroup\$ @Okx: I'm afraid not. It won't work for [5,2] for example. \$\endgroup\$ – Emigna Sep 20 '17 at 17:28
4
\$\begingroup\$

Ohm v2, 4 bytes

Δ2<Å

Try it online!

How?

Δ2<Å   ~ Full program.

Δ      ~ Absolute deltas.
 2<    ~ Is smaller than 2?
   Å   ~ Check if all elements are truthy.
\$\endgroup\$
3
\$\begingroup\$

PowerShell, 62 bytes

param($a)$l=$a[0];($a|?{$_-$l-in1..-1;$l=$_}).count-eq$a.count

Try it online!

PowerShell doesn't have a .map or .some or similar command, so here we're individually checking each delta.

We take input $a and set $l equal to the first element. Then we loop through $a and take out each element where |?{...} the difference $_-$l is -in the range 1,0,-1. We then set $l equal to the current element. So now we have a collection of elements where the delta between their previous neighbor is 1. We take the .count of that and check whether it's -equal to the .count of the array as a whole. If it is, then every delta is 1 or less, so it's an insignificant array. That Boolean result is left on the pipeline, and output is implicit.

\$\endgroup\$
  • \$\begingroup\$ You can save 1 byte by getting rid of the param and doing $l=($a=$args)[0] \$\endgroup\$ – briantist Sep 21 '17 at 20:49
  • \$\begingroup\$ @briantist That doesn't work, though. For example. This is because it's setting $l to be the whole input array in your suggestion. \$\endgroup\$ – AdmBorkBork Sep 21 '17 at 20:54
  • \$\begingroup\$ I think it just requires changing the way you give arguments in TIO (each element needs to be specified separately). The way you have it now, the first element of $args is itself the whole array. Example \$\endgroup\$ – briantist Sep 21 '17 at 20:57
  • \$\begingroup\$ That feels cheaty... \$\endgroup\$ – AdmBorkBork Sep 21 '17 at 21:06
  • \$\begingroup\$ I think that's actually the correct way to use $args. If you called a script or function with a series of arguments separated as spaces, it would come in as separate elements in $args, and for TIO that's how to emulate that. I've personally used it that way many times before, but to each their own :) \$\endgroup\$ – briantist Sep 21 '17 at 21:10
2
\$\begingroup\$

Python 3, 45 bytes

lambda k:all(-2<x-y<2for x,y in zip(k,k[1:]))

Try it online! or Try the test suite.

Thanks to Jonathan Frech for -2 bytes.

\$\endgroup\$
  • \$\begingroup\$ abs(x-y)<2 -> -2<x-y<2. \$\endgroup\$ – Jonathan Frech Sep 20 '17 at 15:46
2
\$\begingroup\$

Java (OpenJDK 8), 78 bytes

a->{int p=0,i=1;for(;i<a.length;p+=Math.abs(a[i]-a[i++-1])>1?1:0);return p<1;}

Try it online!

\$\endgroup\$
2
\$\begingroup\$

MATL, 6 5 bytes

d|2<A

-1 byte thanks to Giuseppe

Try it online! or Verify all test-cases

\$\endgroup\$
  • \$\begingroup\$ I think per meta consensus you can use d|2< instead, as an array with a zero value is falsey in MATL. \$\endgroup\$ – Giuseppe Sep 20 '17 at 15:56
  • 1
    \$\begingroup\$ Or d|2<A for something closer to your original answer. \$\endgroup\$ – Giuseppe Sep 20 '17 at 15:59
  • 1
    \$\begingroup\$ @Giuseppe No they can't: The truthy / falsy values have to be distinct and consistent. \$\endgroup\$ – Mr. Xcoder Sep 20 '17 at 15:59
  • \$\begingroup\$ @Mr.Xcoder "an array of all 1s for truthy" and "an array containing at least one zero for falsey" isn't distinct and consistent? \$\endgroup\$ – Giuseppe Sep 20 '17 at 16:01
  • 2
    \$\begingroup\$ @Giuseppe "an array of all 1s for truthy" and "an array containing at least one zero for falsey" isn't distinct and consistent? - No, that is not acceptable, because they are inconsistent. \$\endgroup\$ – user70974 Sep 20 '17 at 16:13
2
\$\begingroup\$

anyfix, 9 bytes

I€A€2<»/&

Try it online!

I€A€2<»/&  Main Link
I          Deltas
 €         For each element
  A        Take its absolute value
   €  »    For each element
    2<     Is it less than two?
       /   Reduce over
        &  Logical AND

This is mostly a port of the 05AB1E solution except terrible because anyfix doesn't have autovectorization and other cool things

\$\endgroup\$
2
\$\begingroup\$

C, 61 56 bytes

Thanks to @scottinet for saving five bytes!

r;f(a,n)int*a;{for(r=1;--n;r=(*a-*++a)/2?0:r);return r;}

Try it online!

C (gcc), 47 bytes

r;f(a,n)int*a;{for(r=1;--n;r=(*a-*++a)/2?0:r);}

Try it online!

\$\endgroup\$
  • \$\begingroup\$ And if it is allowed / if you feel like it, you may save 9 more bytes by storing the result in r instead of returning it. :-) \$\endgroup\$ – scottinet Sep 20 '17 at 20:05
  • \$\begingroup\$ @scottinet I considered that, but it's not valid C even though it happens to work with gcc. It's allowed, though, so I guess I'll just include it as an alternate version. \$\endgroup\$ – Steadybox Sep 20 '17 at 20:08
  • 2
    \$\begingroup\$ @scottinet Assigning a variable at the end of a function puts that value in the function's return adress, making it feel like it is returning the value. However, this behaviour is not part of the C specifications, thereby not guarenteed to work. It can also break with certain optimizing compiler flags. \$\endgroup\$ – Jonathan Frech Sep 20 '17 at 20:25
  • 2
    \$\begingroup\$ @scottinet Ah, I am sorry. I think that would not be allowed as you cannot simply assign variables in your solution per agreed upon rule. As an example, using globally defined variables instead of function arguments would not be allowed either. Your task is to write a fully functional program / function. \$\endgroup\$ – Jonathan Frech Sep 20 '17 at 20:33
  • 1
    \$\begingroup\$ @JonathanFrech languages are defined by their implementation here, so if you have a compiler which produces consistent results then the answer is valid, even if formally UB. \$\endgroup\$ – Quentin Sep 21 '17 at 11:19
2
\$\begingroup\$

Clojure, 35 bytes

#(every? #{-1 0 1}(map -(rest %)%))

How neat is that?

\$\endgroup\$
2
\$\begingroup\$

TI-Basic, 6 7 bytes

prod(2>abs(ΔList(Ans

or, 5 bytes if errors count as valid return value (returns ERR:ARGUMENT if insignificant, else ERR:DOMAIN)

augment(sin⁻¹(ΔList(Ans
\$\endgroup\$
  • 1
    \$\begingroup\$ This should probably have abs(ΔList(Ans, or else drops by more than 1 (such as in {5,3,1} or in the test case {3,4,5,6,7,8,7,5}) don't get detected. \$\endgroup\$ – Misha Lavrov Sep 24 '17 at 1:19
  • \$\begingroup\$ @MishaLavrov thanks, you're right! \$\endgroup\$ – Oki Sep 24 '17 at 20:45
1
\$\begingroup\$

JavaScript (ES6), 37 36 bytes

(a,u)=>!a.some(e=>(e-=(u=e))>1|e<-1)

Edit: Saved 1 byte by stealing @Arnauld's trick.

\$\endgroup\$
  • \$\begingroup\$ You could use currying: a=>u=>!a.some(e=>(e-=(u=e))>1|e<-1) \$\endgroup\$ – Bálint Sep 24 '17 at 10:30
1
\$\begingroup\$

Pyth, 7 bytes

._I#I.+

Test Suite

Returns true/false.

Explanation:

     .+ Deltas, returns differences between consecutive values.
._      Signum, returns the sign of a number (1, 0, or -1).  Note that this should
             be equal to the input for insignificant arrays.
  I     Tests if it is equal to the input...
   #    For each in the input, and filter out those that aren't...
    I   And make sure none have been filtered out.
\$\endgroup\$
1
\$\begingroup\$

Mathematica, 34 bytes

Differences@#~MatchQ~{(1|0|-1)..}&

Explanation

                                 & (* Function *)
Differences                        (* which takes the consecutive differences*)
           @#                      (* of the input list *)
             ~MatchQ~              (* and returns whether it matches *)
                     {(1|0|-1)..}  (* a list consisting of one or more 1s, 0s, or -1s *)
\$\endgroup\$
1
\$\begingroup\$

Java (OpenJDK 8), 60 bytes

a->{int r=1,p=a[0];for(int i:a)r|=(r=p-(p=i))*r;return r<2;}

Try it online!

  • 5 bytes thanks to @Nevay!
\$\endgroup\$
  • 1
    \$\begingroup\$ You can use r in the loop to calculate (p-n) only once, >>1 can be /2, or removed if you use | instead of +: a->{int r=1,p=a[0];for(int i:a)r|=(r=p-(p=i))*r;return r<2;} (60 bytes). \$\endgroup\$ – Nevay Sep 20 '17 at 20:12
  • \$\begingroup\$ Cheers @Nevay, thank you! Perfect golfing, as usual ;-) \$\endgroup\$ – Olivier Grégoire Sep 20 '17 at 20:29
  • \$\begingroup\$ can you explain me how does it work? thank you! \$\endgroup\$ – blurstream Sep 22 '17 at 9:01
1
\$\begingroup\$

Swift 4, 52 bytes

{!zip($0.dropFirst(),$0).map(-).contains{1<abs($0)}}

Test suite:

let isInsignificant: (_ array: [Int]) -> Bool = {!zip($0.dropFirst(),$0).map(-).contains{1<abs($0)}}

let testcases: [(input: [Int], expected: Bool)] = [
    (input: [1, 2, 3, 4, 3, 4, 5, 5, 5, 4], expected: true),
    (input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 8], expected: true),
    (input: [3, 3, 3, 3, 3, 3, 3],          expected: true),
    (input: [3, 4, 4, 4, 3, 3, 3, 4, 4, 4], expected: true),
    (input: [1, 2, 3, 4],                   expected: true ),
    (input: [5, 4, 3, 2],                   expected: true ),
    (input: [1, 3, 5, 7, 9, 7, 5, 3, 1],    expected: false),
    (input: [1, 1, 1, 2, 3, 4, 5, 6, 19],   expected: false),
    (input: [3, 4, 5, 6, 7, 8, 7, 5],       expected: false),
    (input: [1, 2, 4, 10, 18, 10, 100],     expected: false),
    (input: [10, 20, 30, 30, 30],           expected: false),
]


for (caseNumber, testcase) in testcases.enumerated() {
    let actual = isInsignificant(testcase.input)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \(testcase.input) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}
\$\endgroup\$
1
\$\begingroup\$

APL, 13 bytes

{×/(|2-/⍵)<2}

First APL answer \o/

Note: I am a bot owned by Hyper Neutrino. I exist mainly for chat testing.

Explanation

{×/(|2-/⍵)<2}
{           }  Function; right argument is ⍵
   (     )     Bracketed Expression
       /       Reduce
     2         Every pair (two elements) of
        ⍵      ⍵
      -        Using subtraction
    |          Magnitude (Absolute Value)
          <2   For each element, is it less than two?
  /            Reduce over
 ×             Multiplication (Product) (All)
\$\endgroup\$
  • 1
    \$\begingroup\$ 11 bytes as tacit - ∧/2>(|2-/⊢) \$\endgroup\$ – Uriel Oct 30 '17 at 21:52

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy