Dzieci, które uczą się liczyć, często znają biegi liczb, ale nie wydają się prawidłowo układać tych przebiegów.

Na przykład mogą powiedzieć:

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

Czasami dzieci zdają sobie sprawę, że pominęły niektóre liczby i wracają:

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

Jest to wyraźnie najlepszy wzór. Musimy je zidentyfikować.

Aby zidentyfikować te listy:

1. Identyfikujemy minimum Mi maksimum Nlisty

2. Przechodzimy przez listę. Jeśli bieżąca liczba jest większa lub równa dowolnemu członkowi listy po jej prawej stronie, usuwamy bieżący numer.

3. Jeśli pozostała lista zawiera wszystkie liczby od Mdo N, to zwracamy prawdziwą wartość.

Możesz założyć, że twoja lista wejściowa będzie zawierać co najmniej 1 element. Możesz założyć, że wszystkie liczby całkowite będą nieujemne.

Przypadki testowe:

Prawda:

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

To jest gra w golfa , więc udziel odpowiedzi tak krótko, jak to możliwe!

05AB1E , 5 bajtów

Nie jestem w 100% pewien, że to działa, ale przechodzi wszystkie testy i nie mogłem znaleźć żadnej sytuacji, w której się nie powiedzie.

Ú¥1QP

Wypróbuj online!

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

Galaretka , 10 9 bajtów

ṀrṂɓṚ«\Q⁼

Wypróbuj online!

Jak to działa

Ṁ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 bajtów

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

Wypróbuj online!

Python 2 , 81 bajtów

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

Wypróbuj online!

PHP , 148 130 bajtów

-18 bajtów, dzięki @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);

Wypróbuj online!

Java 8, 264 262 bajtów

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

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

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)

Prawdopodobnie można to jeszcze pograć w golfa. Pętle nad elementami xsprawdzają, czy wszystkie nadchodzące wartości są większe, i dopiero wtedy zachowują ten element. Po pętli tworzy sekwencję od min(x)do max(x)i sprawdza, %in%czy wszystkie wartości są zawarte w przyciętej wersji pliku x.

JavaScript (ES6), 60 bajtów

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

Nie golfowany:

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

To jest prostszy algorytm:

Iteruj tablicę w odwrotnej kolejności i upewnij się, że każda liczba (oprócz pierwszej) jest o jeden mniejsza lub równa liczbie już widzianej.

Skrawek:

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 bajty

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

Wypróbuj online!

Bezpośrednia implementacja definicji, w której gusuwa elementy, jeśli są one> = niż elementy po prawej stronie.

C #, 69 bajtów

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

W skrócie:
s = równanie wejściowe
bierze się z elementu s, w którym wszystkie elementy po tym (pomiń (I) ndex + 1 elementy), bieżąca wartość jest większa,
policz je i sprawdź, czy pozostała kwota jest równa oczekiwanej kwocie ((maksymalna) wartość imum minus (min) imum) liczba liczb

Wypróbuj online!

JavaScript (ES6), 82 73 72 70 bajtów

Zwraca wartość logiczną.

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

W jaki sposób?

Iterujemy po każdym elemencie x tablicy wejściowej a , śledząc maksymalną napotkaną wartość m oraz liczbę -k wartości, które nie są większe lub równe dowolnemu elementowi po ich prawej stronie. Z definicji prawidłowe wartości pojawiają się w ściśle rosnącej kolejności.

Używamy filter()zamiast map(), aby wszystkie elementy zostały odfiltrowane, aż k zmieni się w ujemny. To pozwala nam wyodrębnić pierwszy poprawny element, który jest również gwarantowaną wartością minimalną tablicy.

Na koniec testujemy, czy minimum - (maximum + 1) == -number_of_valid_elements:

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

Przypadki testowe

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