¿Soy un conjunto insignificante?

40

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.

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.

code-golf  number  array-manipulation  decision-problem 
— Martin Ender
fuente
¿Los valores de verdad / falsedad realmente tienen que ser verdaderos / falsos en nuestro lenguaje de elección, o podemos usar dos valores distintos y consistentes?
— Martin Ender
1
@MartinEnder Dos valores distintos y consistentes. PD Perdón por la respuesta tardía
2
El texto dice que se le dará una matriz de enteros, pero que solo las matrices de enteros positivos pueden ser insignificantes. ¿Deberíamos estar preparados para una serie de enteros negativos?
— Mark S.

Respuestas:

24

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.
— Sr. Xcoder
fuente
2
Pno funcionaría, porque si todas las diferencias fueran 1salida 1, pero si una de ellas fuera 0, ¿saldría 0? ¿Y si una diferencia fuera la 5otra 0, todavía lo haría 0?
— Tas
1
¿Qué pasa con el requisito de "enteros positivos"?
— 3D1T0R
19

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

Mostrar fragmento de código

— Arnauld
fuente
29 bytes:a=>!a.some(v=>(a-(a=v))**2>1)
— Johan Karlsson
@JohanKarlsson Ah sí, la entrada está garantizada para contener al menos 2 elementos, así que eso es seguro. ¡Muchas gracias!
— Arnauld
6

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
— Erik el Outgolfer
fuente
5

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.
— Sr. Xcoder
fuente
No tengo idea de por qué pensé en I#lugar de M.
— Steven H.
5

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
— Justin Mariner
fuente
5

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!)
— Grzegorz Puławski
fuente
3
Poca mejora: a=>a.Zip(a.Skip(1),(x,y)=>x-y).All(x=>x*x<4)evita la negación !.
— Jeppe Stig Nielsen
@JeppeStigNielsen increíble, gracias!
— Grzegorz Puławski
5

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.

— Ramillies
fuente
¿Son esos dos espacios realmente necesarios?
— Jonathan Frech
@ JonathanFrech: La correcta probablemente no. También me di cuenta de que .rotateno se necesita aquí.
— Ramillies
Demonios, incluso el izquierdo podría eliminarse. Realmente no entiendo dónde se requiere el espacio en blanco y dónde no ...
— Ramillies
Puede escribir en -2<lugar de -1≤y en <2lugar de ≤1guardar cuatro bytes más.
— Sean
Er, supongo que en realidad tienes que revertir las comparaciones 2>...>-2para evitar interpretarlas de <manera errónea.
— Sean
3

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.

— AdmBorkBork
fuente
Puede guardar 1 byte deshaciéndose del param y haciendo$l=($a=$args)[0]
— briantist
@briantist Eso no funciona, sin embargo. Por ejemplo. Esto se debe a que está configurado $lpara ser la matriz de entrada completa en su sugerencia.
— AdmBorkBork
Creo que solo requiere cambiar la forma de dar argumentos en TIO (cada elemento debe especificarse por separado). De la forma en que lo tiene ahora, el primer elemento de $argssí mismo es toda la matriz. Ejemplo
— briantist el
Eso se siente engañoso ...
— AdmBorkBork
Creo que esa es realmente la forma correcta de usar $args. Si llamaste a un script o una función con una serie de argumentos separados como espacios, aparecería como elementos separados $args, y para TIO esa es la forma de emular eso. Personalmente lo he usado de esa manera muchas veces antes, pero para cada uno lo suyo :)
— briantist
2

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

— Cinaski
fuente
Creo que por meta consenso puedes usar d|2<en su lugar, ya que una matriz con un valor cero es falsey en MATL.
— Giuseppe
1
O d|2<Apor algo más cercano a tu respuesta original.
— Giuseppe
1
@Giuseppe No, no pueden: los valores de verdad / falsedad deben ser distintos y consistentes .
— Sr. Xcoder
@ Mr.Xcoder "¿una matriz de todos los 1 para la verdad" y "una matriz que contiene al menos un cero para falsey" no es distinta y consistente?
— Giuseppe
2
@Giuseppe "una matriz de todos los 1 para la verdad" y "una matriz que contiene al menos un cero para falsey" no es distinta y consistente? - No, eso no es aceptable, porque son inconsistentes.
2

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

— Hiperneutrino
fuente
2

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!

— Steadybox
fuente
Y si está permitido / si lo desea, puede guardar 9 bytes más almacenando el resultado en rlugar de devolverlo. :-)
— scottinet
@scottinet Lo consideré, pero no es válido C a pesar de que funciona con gcc. Sin embargo, está permitido, así que supongo que lo incluiré como una versión alternativa.
— Steadybox
2
@scottinet Asignar una variable al final de una función coloca ese valor en la dirección de retorno de la función, haciendo que parezca que está devolviendo el valor. Sin embargo, este comportamiento no forma parte de las especificaciones de C, por lo que no está garantizado para funcionar. También puede romperse con ciertos indicadores de compilación de optimización.
— Jonathan Frech
2
@ scottinet Ah, lo siento. Creo que eso no estaría permitido ya que no puede simplemente asignar variables en su solución según la regla acordada. Como ejemplo, tampoco se permitiría usar variables definidas globalmente en lugar de argumentos de función. Su tarea es escribir un programa / función completamente funcional.
— Jonathan Frech
1
Los idiomas de @JonathanFrech se definen por su implementación aquí, por lo que si tiene un compilador que produce resultados consistentes, la respuesta es válida, incluso si es formalmente UB.
— Quentin
2

Clojure, 35 bytes

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

¿Qué tan limpio es eso?

— NikoNyrh
fuente
2

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
— Oki
fuente
1
Esto probablemente debería tener abs(ΔList(Ans, o de lo contrario cae en más de 1 (como en {5,3,1} o en el caso de prueba {3,4,5,6,7,8,7,5}) no obtener detectado
— Misha Lavrov
@MishaLavrov gracias, tienes razón!
— Oki
1

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.

— Neil
fuente
Puede usar curry:a=>u=>!a.some(e=>(e-=(u=e))>1|e<-1)
— Bálint
1

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.
— Steven H.
fuente
1

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 *)
— ngenisis
fuente
1

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!
— Olivier Grégoire
fuente
1
Puede usar ren el ciclo para calcular (p-n)solo una vez, >>1puede ser /2o eliminarse si usa en |lugar de +: a->{int r=1,p=a[0];for(int i:a)r|=(r=p-(p=i))*r;return r<2;}(60 bytes).
— Nevay
Saludos @Nevay, gracias! Golf perfecto, como siempre ;-)
— Olivier Grégoire
me puedes explicar como funciona ¡gracias!
— blurstream
1

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!")
}
— Alexander - Restablece a Monica
fuente
1

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)
— NeutrinoBot
fuente
1
11 bytes como tácito - ∧/2>(|2-/⊢)
— Uriel
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.