Les enfants qui apprennent à compter connaissent souvent des séries de chiffres, mais ne semblent pas pouvoir les assembler correctement.

Par exemple, ils pourraient dire:

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

Parfois, les enfants se rendent compte qu'ils ont sauté certains chiffres et reviennent:

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

C'est clairement le modèle supérieur. Nous devons les identifier.

Pour identifier ces listes:

1. Nous identifions le minimum Met le maximum Nde la liste

2. Nous parcourons la liste. Si le nombre actuel est supérieur ou égal à un membre de la liste à sa droite, nous supprimons le nombre actuel.

3. Si la liste restante contient tous les nombres de Mà N, alors nous retournons une valeur véridique.

Vous pouvez supposer que votre liste d'entrées contiendra au moins 1 élément. Vous pouvez supposer que tous les entiers seront non négatifs.

Cas de test:

Vérité:

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

Il s'agit de code-golf , alors faites vos réponses aussi courtes que possible!

05AB1E , 5 octets

Je ne suis pas sûr à 100% que cela fonctionne, mais il passe tous les cas de test et je n'ai trouvé aucune situation où il échoue.

Ú¥1QP

Essayez-le en ligne!

Ú¥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

Gelée , 10 9 octets

ṀrṂɓṚ«\Q⁼

Essayez-le en ligne!

Comment ça fonctionne

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

Rubis , 59 54 41 octets

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

Essayez-le en ligne!

Python 2 , 81 octets

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

Essayez-le en ligne!

PHP , 148 130 octets

-18 octets, merci @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);

Essayez-le en ligne!

Java 8, 264 262 octets

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

Explication:

Essayez-le ici.

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 octets

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)

Cela peut probablement être approfondi. Boucle sur les éléments de x, vérifie si toutes les valeurs à venir sont plus grandes et ne conserve que cet élément. Après la boucle, il crée une séquence de min(x)à max(x)et vérifie %in%si toutes les valeurs sont incluses dans la version élaguée de x.

JavaScript (ES6), 60 octets

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

Non golfé:

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

Ceci est un algorithme plus simple:

Répétez le tableau en sens inverse et assurez-vous que chaque nombre (sauf le premier) est inférieur ou égal à un nombre déjà vu.

Fragment:

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 octets

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

Essayez-le en ligne!

Une implémentation directe de la définition où gsupprime les éléments s'ils sont> = que les éléments à sa droite.

C #, 69 octets

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

En bref:
s = entrée (s) équation
prise de l'élément s où tous les éléments après celui-ci (sauter (I) ndex + 1 éléments), la valeur actuelle est plus élevée
comptez-les et voyez si le montant restant est égal au montant attendu ((max) valeur imum moins (min) imum) quantité de nombres

Essayez-le en ligne!

JavaScript (ES6), 82 73 72 70 octets

Renvoie un booléen.

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

Comment?

Nous itérons sur chaque élément x du tableau d'entrée a , en gardant une trace de la valeur maximale rencontrée m et du nombre -k de valeurs qui ne sont ni supérieures ni égales à aucun membre à leur droite. Par définition, les valeurs valides apparaissent dans un ordre strictement croissant.

Nous utilisons filter()plutôt que map(), afin que tous les éléments soient filtrés jusqu'à ce que k devienne négatif. Cela nous permet d'isoler le premier élément valide, qui est également garanti comme étant la valeur minimale du tableau.

Enfin, nous testons si minimum - (maximum + 1) == -number_of_valid_elements:

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

Cas de test

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]));