Дети, которые учатся считать, часто знают серии чисел, но, похоже, не могут правильно их составить.

Например, они могут сказать:

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

Иногда дети понимают, что пропустили некоторые цифры, и возвращаются:

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

Это явно превосходный образец. Нам нужно их идентифицировать.

Чтобы определить эти списки:

1. Определяем минимум Mи максимум Nиз списка

2. Мы шагаем по списку. Если текущий номер больше или равен любому члену списка справа от него, мы удаляем текущий номер.

3. Если оставшийся список содержит все числа от Mдо N, то мы возвращаем истинное значение.

Вы можете предположить, что ваш входной список будет содержать как минимум 1 элемент. Вы можете предположить, что все целые числа будут неотрицательными.

Тестовые случаи:

Truthy:

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

Это код-гольф , поэтому делайте ваши ответы как можно короче!

05AB1E , 5 байтов

Я не уверен на 100%, что это работает, но он проходит все тестовые случаи, и я не смог найти ни одной ситуации, когда это не удалось.

Ú¥1QP

Попробуйте онлайн!

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

Желе , 10 9 байт

ṀrṂɓṚ«\Q⁼

Попробуйте онлайн!

Как это устроено

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

Рубин , 59 54 41 байт

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

Попробуйте онлайн!

Python 2 , 81 байт

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

Попробуйте онлайн!

PHP , 148 130 байт

-18 байт, спасибо @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);

Попробуйте онлайн!

Java 8, 264 262 байта

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

Объяснение:

Попробуй это здесь.

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 байт

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)

Это может быть, вероятно, дальше. Перебирает элементы x, проверяет, все ли последующие значения больше, и только затем сохраняет этот элемент. После цикла он создает последовательность из min(x)к max(x), и проверяет с , %in%если все значения включены в обрезке версии x.

JavaScript (ES6), 60 байт

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

Ungolfed:

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

Это более простой алгоритм:

Выполните итерацию массива в обратном порядке и убедитесь, что каждое число (кроме первого) на единицу меньше или равно уже увиденному числу.

Отрывок:

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 байта

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

Попробуйте онлайн!

Прямая реализация определения, где gэлементы удаляются, если они> =, чем элементы справа от него.

C #, 69 байт

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

Вкратце:
s = input (s) equence
берет из элемента s, где все элементы после этого (skip (I) ndex + 1 items), текущее значение выше,
подсчитайте их, и посмотрите, равна ли оставшаяся сумма ожидаемой ((max) imum value минус (min) imum) количество чисел

Попробуйте онлайн!

JavaScript (ES6), 82 73 72 70 байт

Возвращает логическое значение.

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

Как?

Мы выполняем итерацию для каждого элемента x входного массива a , отслеживая максимальное встречаемое значение m и число -k значений, которые не превышают или не равны ни одному из элементов справа от них. По определению действительные значения отображаются в строго возрастающем порядке.

Мы используем filter()вместо map(), чтобы все элементы отфильтровывались, пока k не станет отрицательным. Это позволяет нам изолировать первый действительный элемент, который также гарантированно будет минимальным значением массива.

Наконец, мы проверяем minimum - (maximum + 1) == -number_of_valid_elements:

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

Контрольные примеры

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