Una matriz insignificante es una matriz de enteros positivos, donde las diferencias absolutas entre elementos consecutivos son todas menores o iguales a 1 .

Por ejemplo, la siguiente matriz es insignificante:

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

Porque las diferencias (absolutas) correspondientes son:

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

Todos los cuales son más pequeños o iguales a 1 .

Su tarea es determinar si un conjunto dado de enteros es insignificante.

• Puede suponer que la matriz siempre contiene al menos dos elementos.
• Se aplican las reglas estándar de entrada y salida . Puede tomar entrada (y salida) en cualquier formato razonable.
• Las lagunas predeterminadas están prohibidas.
• Los valores de verdad / falsedad deben ser distintos y consistentes.
• Este es el código de golf , por lo que la respuesta más corta en bytes gana.

Casos de prueba

Entrada -> Salida

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

Usé los valores truey false.

Jalea , 3 bytes

IỊẠ

Pruébalo en línea!

¿Cómo?

Simplemente el desafío perfecto para Jelly.

IỊẠ Programa completo.

I incrementos; Obtenga la diferencia entre elementos consecutivos.
 Ị insignificante; devuelve abs (número) ≤ 1.
  Ạ Todos; devuelve 1 si todos los elementos son verdaderos, 0 de lo contrario.

JavaScript (ES7), 33 29 bytes

Guardado 4 bytes gracias a @JohanKarlsson

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

¿Cómo?

Cuando se les coacciona Number, se evalúan las matrices de al menos dos elementos NaN. Al reutilizar la entrada a como la variable que contiene el valor anterior, la primera iteración de some () siempre da como resultado ([v0, v1, ...] - a [0]) ** 2 = NaN , sin importar el valor de a [0] . Por lo tanto, la primera prueba siempre es falsa y las comparaciones reales comienzan en la segunda iteración, tal como deben ser.

Casos de prueba

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

Python 3 , 40 bytes

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

Pruébalo en línea!

Mathematica, 24 bytes

Max@Abs@Differences@#<2&

Python 2 , 35 bytes

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

Existe con el código de estado 1 para matrices insignificantes, con el código de estado 0 de lo contrario.

Pruébalo en línea!

Casco , 4 bytes

ΛεẊ-

Pruébalo en línea!

Explicación:

ΛεẊ- 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

Octava , 21 bytes

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

Función anónima que ingresa un vector numérico y sale 1si es insignificante o 0no.

Pruébalo en línea!

Haskell , 34 33 bytes

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

Pruébalo en línea! -1 byte gracias a @ user1472751

La solución sin puntos es uno, dos, solo un byte ( gracias a -1 byte de @Dennis ) más corto que el enfoque recursivo:

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

Pruébalo en línea!

Pyth , 6 bytes

._MI.+

Verifique todos los casos de prueba.

Pyth , 8 bytes

.A<R2aVt

Pruébalo en línea!

Explicación

._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.

Protón , 41 bytes

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

Pruébalo en línea!

-16 bytes gracias al Sr. Xcoder
-2 bytes
-6 bytes gracias al Sr. Xcoder

Japt , 6 bytes

äa e<2

Pruébalo en línea!

Explicación

ä        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

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

-1 byte gracias a Jeppe Stig Nielsen

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

El recuento de bytes también incluye:

using System.Linq;

Pruébalo en línea!

Explicación:

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!)

Perl 6 , 25 bytes

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

Pruébalo en línea!

Esto debería ser bastante legible. Lo único menos obvio aquí es que el operador zip Zdejará de comprimir cuando se agote la lista más corta (eliminamos el primer elemento de la lista a la derecha) y que el subíndice vacío .[], llamado corte Zen, proporciona toda la lista. .skipdevuelve la lista sin el primer elemento.

R , 30 26 bytes

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

Pruébalo en línea!

05AB1E , 5 bytes

¥Ä2‹P

Pruébalo en línea!

Explicación

¥        # calculate deltas
 Ä       # absolute values
  2‹     # smaller than 2
    P    # product

Ohm v2 , 4 bytes

Δ2<Å

Pruébalo en línea!

¿Cómo?

Δ2<Å   ~ Full program.

Δ      ~ Absolute deltas.
 2<    ~ Is smaller than 2?
   Å   ~ Check if all elements are truthy.

PowerShell , 62 bytes

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

Pruébalo en línea!

PowerShell no tiene una .mapo .somecomando o similar, por lo que aquí estamos comprobar individualmente cada delta.

Tomamos entrada $ay establecemos $ligual al primer elemento. Luego recorremos $ay sacamos cada elemento donde |?{...}la diferencia $_-$les -inel rango 1,0,-1. Luego establecemos $ligual al elemento actual. Así que ahora tenemos una colección de elementos donde el delta entre su vecino anterior es 1. Tomamos el .countde eso y verificamos si es -equal al .countdel conjunto como un todo. Si es así, cada delta es 1 o menos, por lo que es una matriz insignificante. Ese resultado booleano se deja en la tubería y la salida es implícita.

Python 3 , 45 bytes

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

Pruébalo en línea! o Prueba la suite de prueba.

Gracias a Jonathan Frech por -2 bytes.

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;}

Pruébalo en línea!

MAT ,6 6 5 bytes

d|2<A

-1 byte gracias a Giuseppe

Pruébalo en línea! o Verificar todos los casos de prueba

anyfix , 9 bytes

I€A€2<»/&

Pruébalo en línea!

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

Esto es principalmente un puerto de la solución 05AB1E, excepto terrible porque anyfix no tiene autovectorización y otras cosas interesantes

C, 61 56 bytes

¡Gracias a @scottinet por guardar cinco bytes!

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

Pruébalo en línea!

C (gcc), 47 bytes

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

Pruébalo en línea!

Clojure, 35 bytes

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

¿Qué tan limpio es eso?

TI-Basic, 6 7 bytes

prod(2>abs(ΔList(Ans

o 5 bytes si los errores cuentan como valor de retorno válido (devuelve ERR:ARGUMENTsi es insignificante, de lo contrario ERR:DOMAIN)

augment(sin⁻¹(ΔList(Ans

JavaScript (ES6), 37 36 bytes

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

Editar: Guardado 1 byte robando el truco de @ Arnauld.

Pyth, 7 bytes

._I#I.+

Banco de pruebas

Devuelve verdadero / falso.

Explicación:

     .+ 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.

Mathematica, 34 bytes

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

Explicación

                                 & (* 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 *)

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;}

Pruébalo en línea!

• 5 bytes gracias a @Nevay!

Swift 4, 52 bytes

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

Banco de pruebas:

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!")
}

APL, 13 bytes

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

Primera respuesta APL \ o /

Nota: Soy un bot propiedad de Hyper Neutrino. Existo principalmente para pruebas de chat.

Explicación

{×/(|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)