Anak-anak yang sedang belajar berhitung sering mengetahui angka-angka, tetapi sepertinya tidak bisa menggabungkan angka-angka itu dengan benar.

Misalnya, mereka mungkin berkata:

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

Terkadang anak-anak akan menyadari bahwa mereka melewatkan beberapa angka, dan kembali:

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

Ini jelas merupakan pola superior. Kita perlu mengidentifikasi mereka.

Untuk mengidentifikasi daftar ini:

1. Kami mengidentifikasi minimum Mdan maksimum Ndaftar

2. Kami menelusuri daftar. Jika nomor saat ini lebih besar dari atau sama dengan anggota daftar di sebelah kanannya, maka kami menghapus nomor saat ini.

3. Jika daftar yang tersisa berisi semua angka dari Mhingga N, maka kami mengembalikan nilai yang sebenarnya.

Anda dapat mengasumsikan daftar input Anda akan mengandung setidaknya 1 elemen. Anda dapat mengasumsikan bahwa semua bilangan bulat akan menjadi non-negatif.

Kasus uji:

Benar:

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

Ini kode-golf , jadi buat jawaban Anda sesingkat mungkin!

05AB1E , 5 byte

Saya tidak 100% yakin ini berfungsi, tetapi ia melewati semua test case dan saya tidak dapat menemukan situasi di mana ia gagal.

Ú¥1QP

Cobalah 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

Jelly , 10 9 byte

ṀrṂɓṚ«\Q⁼

Cobalah online!

Bagaimana itu bekerja

Ṁ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)]}

Cobalah online!

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)

Cobalah online!

PHP , 148 130 byte

-18 byte, terima kasih @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);

Cobalah online!

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

Penjelasan:

Coba di sini.

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)

Ini mungkin bisa diturunkan lebih lanjut. Loop elemen x, memeriksa apakah semua nilai yang akan datang lebih besar, dan hanya kemudian menyimpan elemen itu. Setelah loop itu membuat urutan dari min(x)ke max(x), dan memeriksa dengan %in%apakah semua nilai termasuk dalam versi prun x.

JavaScript (ES6), 60 byte

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

Tidak Disatukan:

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

Ini adalah algoritma yang lebih sederhana:

Iterasi larik secara terbalik, dan pastikan setiap angka (kecuali yang pertama) kurang dari atau sama dengan angka yang sudah terlihat.

Potongan:

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]

Cobalah online!

Implementasi langsung dari definisi di mana gmenghilangkan elemen jika mereka> = daripada elemen di sebelah kanannya.

C #, 69 byte

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

Singkatnya:
s = input (s) persamaan
diambil dari elemen s di mana semua item setelah ini (lewati (I) ndex + 1 item), nilai saat ini lebih tinggi
hitung ini, dan lihat apakah jumlah yang tersisa sama dengan jumlah yang diharapkan ((maks) nilai imum dikurangi (min) imum) jumlah angka

Cobalah online!

JavaScript (ES6), 82 73 72 70 byte

Mengembalikan 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

Bagaimana?

Kami mengulangi pada setiap elemen x dari array input a , melacak nilai maksimum yang ditemui m dan jumlah -k dari nilai yang tidak lebih besar dari atau sama dengan setiap anggota di sebelah kanan mereka. Menurut definisi, nilai yang valid muncul dalam urutan naik yang ketat.

Kita gunakan filter() daripada map(), sehingga semua elemen bisa disaring sampai k berubah menjadi negatif. Ini memungkinkan kita untuk mengisolasi elemen valid pertama, yang juga dijamin sebagai nilai minimum array.

Akhirnya, kami menguji apakah minimum - (maximum + 1) == -number_of_valid_elements:

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

Uji kasus

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