Những đứa trẻ đang học cách đếm thường biết chạy các con số, nhưng dường như không thể đặt chúng chạy cùng nhau.

Ví dụ: họ có thể nói:

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

Đôi khi, những đứa trẻ sẽ nhận ra rằng chúng đã bỏ qua một số con số và quay lại:

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

Đây rõ ràng là mô hình vượt trội. Chúng ta cần xác định chúng.

Để xác định các danh sách này:

1. Chúng tôi xác định mức tối thiểu Mvà tối đa Ncủa danh sách

2. Chúng tôi bước qua danh sách. Nếu số hiện tại lớn hơn hoặc bằng bất kỳ thành viên nào trong danh sách bên phải, thì chúng tôi sẽ xóa số hiện tại.

3. Nếu danh sách còn lại chứa tất cả các số từ Mđến N, sau đó chúng tôi trả về một giá trị trung thực.

Bạn có thể giả sử danh sách đầu vào của bạn sẽ chứa ít nhất 1 yếu tố. Bạn có thể giả định rằng tất cả các số nguyên sẽ không âm.

Các trường hợp thử nghiệm:

Sự thật:

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

Giả mạo:

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

Đây là môn đánh gôn , vì vậy hãy trả lời ngắn gọn nhất có thể!

05AB1E , 5 byte

Tôi không chắc chắn 100% điều này hoạt động, nhưng nó vượt qua tất cả các trường hợp thử nghiệm và tôi không thể tìm thấy bất kỳ tình huống nào khi nó thất bại.

Ú¥1QP

Hãy thử trực tuyến!

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

Thạch , 10 9 byte

ṀrṂɓṚ«\Q⁼

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

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

Hãy thử trực tuyến!

Python 2 , 81 byte

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

Hãy thử trực tuyến!

PHP , 148 130 byte

-18 byte, cảm ơn @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);

Hãy thử trực tuyến!

Java 8, 264 262 byte

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

Giải trình:

Hãy thử nó ở đây.

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 byte

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)

Điều này có thể có thể được đánh golf xuống hơn nữa. Vòng lặp trên các phần tử của x, kiểm tra xem tất cả các giá trị sắp tới có lớn hơn không và chỉ sau đó giữ phần tử đó. Sau vòng lặp, nó tạo một chuỗi từ min(x)đến max(x)và kiểm tra %in%xem tất cả các giá trị có được bao gồm trong phiên bản được cắt tỉa của x.

JavaScript (ES6), 60 byte

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

Ung dung:

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

Đây là một thuật toán đơn giản hơn:

Lặp lại mảng theo chiều ngược lại và đảm bảo mỗi số (trừ số đầu tiên) nhỏ hơn hoặc bằng một số đã thấy.

Đoạn trích:

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 byte

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

Hãy thử trực tuyến!

Việc thực hiện trực tiếp định nghĩa trong đó gloại bỏ các phần tử nếu chúng> = hơn các phần tử bên phải.

C #, 69 byte

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

Tóm lại:
s = input (s) Equence
lấy từ phần tử s trong đó tất cả các mục sau mục này (bỏ qua (I) ndex + 1 mục), giá trị hiện tại cao hơn
đếm những điều này và xem liệu số tiền còn lại có bằng với số tiền dự kiến ​​không ((tối đa) giá trị imum trừ (tối thiểu) imum) số lượng

Hãy thử trực tuyến!

JavaScript (ES6), 82 73 72 70 byte

Trả về một boolean.

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

Làm sao?

Chúng tôi lặp lại trên mỗi phần tử x của mảng đầu vào a , theo dõi giá trị gặp tối đa m và số -k của các giá trị không lớn hơn hoặc bằng bất kỳ thành viên nào bên phải. Theo định nghĩa, các giá trị hợp lệ xuất hiện theo thứ tự tăng dần nghiêm ngặt.

Chúng tôi sử dụng filter()chứ không phải map(), để tất cả các yếu tố được lọc ra cho đến khi k chuyển sang âm. Điều này cho phép chúng ta cô lập phần tử hợp lệ đầu tiên, cũng được đảm bảo là giá trị tối thiểu của mảng.

Cuối cùng, chúng tôi kiểm tra xem minimum - (maximum + 1) == -number_of_valid_elements:

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

Các trường hợp thử nghiệm

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