Los niños que están aprendiendo a contar a menudo conocen series de números, pero parece que no pueden juntar esas series correctamente.

Por ejemplo, podrían decir:

1,2,3,4,7,8,9,10

A veces los niños se darán cuenta de que se saltaron algunos números y volverán:

1,2,3,4,7,8,5,6,7,8,9,10

Este es claramente el patrón superior. Necesitamos identificarlos.

Para identificar estas listas:

1. Identificamos el mínimo My el máximo Nde la lista.

2. Pasamos por la lista. Si el número actual es mayor o igual que cualquier miembro de la lista a su derecha, entonces eliminamos el número actual.

3. Si la lista restante contiene todos los números desde Mhasta N, entonces devolvemos un valor verdadero.

Puede suponer que su lista de entrada contendrá al menos 1 elemento. Puede suponer que todos los enteros serán no negativos.

Casos de prueba:

Verdad:

0
10
0 0 0 
1 0 1
0 1 2 3 4 5 6 7 8 9 10
0 1 2 3 0 1 2 3
0 1 2 3 4 5 5
0 1 1 2 2 3
0 3 6 1 4 7 2 5 8 3 4 5 6 7 8
1 3 5 7 2 3 4 5 6 7
5 6 0 1 2 3 6 7 4 5 6 7
5 6 7 8
5 5 6 7 8
4 6 7 8 3 4 5 6 7 8

Falsy

1 0
4 3 2 1
1 2 3 7 8 9
0 1 2 3 1 3
0 1 2 3 1 3 4
0 1 2 3 1 3 2 4
0 1 2 3 1 3 2 4 3
1 3 5 7 2 4 6 8
0 1 2 1 3 4 5 6
4 5 6 3 4 5

Este es el código de golf , ¡así que haga sus respuestas lo más breve posible!

05AB1E , 5 bytes

No estoy 100% seguro de que esto funcione, pero pasa todos los casos de prueba y no pude encontrar ninguna situación en la que falle.

Ú¥1QP

Pruébalo en línea!

Ú¥1QP   Main link. Argument a
Ú       Reverse uniquify a, keeps only last occurence of each element
 ¥      Get all deltas - all 1 if ascending list
  1Q    Compare all deltas to 1
    P   Product of all results

Jalea , 10 9 bytes

ṀrṂɓṚ«\Q⁼

Pruébalo en línea!

Cómo funciona

ṀrṂɓṚ«\Q⁼  Main link. Argument: A (array)

Ṁ          Yield the maximum of A.
  Ṃ        Yield the minimum of A.
 r         Yield R := [max(A), ... min(A).
   ɓ       Begin a new chain. Left argument: A. Right argument: R
    Ṛ      Reverse A.
     «\    Take the cumulative minimum.
       Q   Unique; deduplicate the results.
        ⁼  Compare the result with R.

Ruby , 59 54 41 bytes

->a{a.reverse|[]==[*a.max.downto(a.min)]}

Pruébalo en línea!

Python 2 , 81 bytes

x=input();r=m=[]
for n in x[::-1]:r=[n][:n<m]+r;m=r[0]
print r==range(m,max(x)+1)

Pruébalo en línea!

PHP , 148 130 bytes

-18 bytes, gracias @Christoph

$a=explode(' ',$argn);$b=range(min($a),max($a));foreach($a as$i=>&$k)for(;++$i<count($a);)$k<$a[$i]?:$k=-1;echo!array_diff($b,$a);

Pruébalo en línea!

Java 8, 264 262 bytes

import java.util.*;l->{int m=Collections.max(l),n=Collections.min(l),i=0,q;for(;i<(q=l.size());i++)if(l.subList(i+1,q).size()>0&&l.get(i)>=Collections.min(l.subList(i+1,q)))l.remove(i--);for(i=0;n<=m;)if(i<l.size()&&l.get(i++)==n)n++;else return 0>1;return 1>0;}

Explicación:

Pruébalo aquí.

import java.util.*;                 // Import for Collections

l->{                                // Method with integer-ArrayList parameter and boolean return-type
  int m=Collections.max(l),         //  Max of the list
      n=Collections.min(l),         //  Min of the list
      i=0,q;                        //  Two temp integers
  for(;i<(q=l.size());i++)          //  Loop (1) over the list
    if(l.subList(i+1,q).size()>0    //   If the sublist right of the current item is not empty
    &&l.get(i)>=Collections.min(l.subList(i+1,q))) 
                                    //   and if the current item is larger or equal to the lowest value of this sublist
      l.remove(i--);                //    Remove the current item from the main list
                                    //  End of loop (1) (implicit / single-line body)
  for(i=0;n<=m;)                    //  Loop (2) from min to max
    if(i<l.size()                   //   If the current item doesn't exceed the list's size
    &&l.get(i++)==n)                //   and the items are in order so far
      n++;                          //    Go to the next item
    else                            //   Else:
      return 0>1;//false            //    Return false
                                    //  End of loop (2) (implicit / single-line body)
  return 1>0;//true                 //  Return true
}                                   // End of method

R, 88 85 bytes

y=NULL;for(i in x<-scan())if(all(i<x[-(1:(F<-F+1))]))y=c(y,i);all(min(x):max(x)%in%y)

Esto probablemente se pueda jugar más golf. Recorre los elementos de x, comprueba si todos los valores próximos son más grandes, y solo entonces mantiene ese elemento. Después del ciclo, crea una secuencia de min(x)a max(x)y verifica %in%si todos los valores están incluidos en la versión podada de x.

JavaScript (ES6), 60 bytes

s=>(o={},s.reverse().every((n,i)=>!i|o[n+1]|o[n]&&(o[n]=1)))

Sin golf:

s=>(
  o={},
  s.reverse().every((n,i)=>
    !i|o[n+1]|o[n]&&(o[n]=1)
  )
)

Este es un algoritmo más simple:

Itere la matriz en reversa y asegúrese de que cada número (excepto el primero) sea uno menor o igual a un número ya visto.

Retazo:

f=

s=>(o={},s.reverse().every((n,i)=>!i|o[n+1]|o[n]&&(o[n]=1)))

console.log('Truthy');
console.log(f([0]))
console.log(f([10]))
console.log(f([0,0,0]))
console.log(f([1,0,1]))
console.log(f([0,1,2,3,4,5,6,7,8,9,10]))
console.log(f([0,1,2,3,0,1,2,3]))
console.log(f([0,1,2,3,4,5,5]))
console.log(f([0,1,1,2,2,3]))
console.log(f([0,3,6,1,4,7,2,5,8,3,4,5,6,7,8]))
console.log(f([1,3,5,7,2,3,4,5,6,7]))
console.log(f([5,6,0,1,2,3,6,7,4,5,6,7]))
console.log(f([5,6,7,8]))
console.log(f([5,5,6,7,8]))
console.log(f([4,6,7,8,3,4,5,6,7,8]))

console.log('Falsy');
console.log(f([1,0]))
console.log(f([4,3,2,1]))
console.log(f([1,2,3,7,8,9]))
console.log(f([0,1,2,3,1,3]))
console.log(f([0,1,2,3,1,3,4]))
console.log(f([0,1,2,3,1,3,2,4]))
console.log(f([0,1,2,3,1,3,2,4,3]))
console.log(f([1,3,5,7,2,4,6,8]))
console.log(f([0,1,2,1,3,4,5,6]))
console.log(f([4,5,6,3,4,5]))

Haskell, 62 bytes

g(a:b)=[a|all(a<)b]++g b
g a=a
f x=g x==[minimum x..maximum x]

Pruébalo en línea!

Una implementación directa de la definición donde gelimina los elementos si son> = que los elementos a su derecha.

C #, 69 bytes

s=>s.Where((e,i)=>s.Skip(i+1).All(r=>e<r)).Count()==s.Max()-s.Min()+1

En resumen:
s = input (s) equence
toma del elemento s donde todos los elementos después de este (omitir (I) ndex + 1 elementos), el valor actual es mayor,
cuente estos, y vea si la cantidad restante es igual a la cantidad esperada ((max) valor imum menos (min) imum) cantidad de números

Pruébalo en línea!

JavaScript (ES6), 82 73 72 70 bytes

Devuelve un booleano.

a=>a.filter((x,i)=>k-=a.every(y=>~i--<0|y>x,m=x>m?x:m),m=k=0)[0]+~m==k

¿Cómo?

Repetimos en cada elemento x de la matriz de entrada a, haciendo un seguimiento del valor máximo encontrado m el número -k de valores que no son mayores o iguales que cualquier miembro a su derecha. Por definición, los valores válidos aparecen en orden estrictamente ascendente.

Usamos en filter()lugar de map(), para que todos los elementos se filtren hasta k se vuelva negativo. Esto nos permite aislar el primer elemento válido, que también se garantiza que es el valor mínimo de la matriz.

Finalmente, probamos si minimum - (maximum + 1) == -number_of_valid_elements :

a.filter(...)[0] + ~m == k

Casos de prueba

let f =

a=>a.filter((x,i)=>k-=a.every(y=>~i--<0|y>x,m=x>m?x:m),m=k=0)[0]+~m==k

console.log('[Truthy]');
console.log(f([0]));
console.log(f([10]));
console.log(f([0,0,0,]));
console.log(f([1,0,1]));
console.log(f([0,1,2,3,4,5,6,7,8,9,10]));
console.log(f([0,1,2,3,0,1,2,3]));
console.log(f([0,1,2,3,4,5,5]));
console.log(f([0,1,1,2,2,3]));
console.log(f([0,3,6,1,4,7,2,5,8,3,4,5,6,7,8]));
console.log(f([1,3,5,7,2,3,4,5,6,7]));
console.log(f([5,6,0,1,2,3,6,7,4,5,6,7]));
console.log(f([5,6,7,8]));
console.log(f([5,5,6,7,8]));
console.log(f([4,6,7,8,3,4,5,6,7,8]));

console.log('[Falsy]');
console.log(f([1,0]));
console.log(f([4,3,2,1]));
console.log(f([1,2,3,7,8,9]));
console.log(f([0,1,2,3,1,3]));
console.log(f([0,1,2,3,1,3,4]));
console.log(f([0,1,2,3,1,3,2,4]));
console.log(f([0,1,2,3,1,3,2,4,3]));
console.log(f([1,3,5,7,2,4,6,8]));
console.log(f([0,1,2,1,3,4,5,6]));
console.log(f([4,5,6,3,4,5]));