Kinder, die das Zählen lernen, kennen oft Zahlenreihen, können diese jedoch nicht richtig zusammensetzen.

Zum Beispiel könnten sie sagen:

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

Manchmal werden Kinder bemerken, dass sie einige Zahlen übersprungen haben und gehen zurück:

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

Dies ist eindeutig das überlegene Muster. Wir müssen sie identifizieren.

So identifizieren Sie diese Listen:

1. Wir identifizieren das Minimum Mund das Maximum Nder Liste

2. Wir gehen die Liste durch. Wenn die aktuelle Nummer größer oder gleich einem Mitglied der Liste rechts davon ist, entfernen wir die aktuelle Nummer.

3. Wenn die verbleibende Liste alle Zahlen von Mbis enthält N, geben wir einen Wahrheitswert zurück.

Sie können davon ausgehen, dass Ihre Eingabeliste mindestens 1 Element enthält. Sie können davon ausgehen, dass alle Ganzzahlen nicht negativ sind.

Testfälle:

Wahrheit:

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

Falsch:

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

Das ist Code-Golf , also machen Sie Ihre Antworten so kurz wie möglich!

05AB1E , 5 Bytes

Ich bin nicht zu 100% sicher, dass dies funktioniert, aber es besteht alle Testfälle und ich konnte keine Situation finden, in der es fehlschlägt.

Ú¥1QP

Probieren Sie es 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

Gelee , 10 9 Bytes

ṀrṂɓṚ«\Q⁼

Probieren Sie es online!

Wie es funktioniert

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

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

Probieren Sie es online!

Python 2 , 81 Bytes

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

Probieren Sie es online!

PHP , 148 130 Bytes

-18 Bytes, danke @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);

Probieren Sie es online!

Java 8, 264 262 Bytes

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

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

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)

Dies kann wahrscheinlich weiter abgespielt werden. Durchläuft die Elemente von x, überprüft, ob alle anstehenden Werte größer sind, und behält nur dann dieses Element bei. Nach der Schleife wird eine Sequenz von min(x)bis erstellt max(x)und geprüft, %in%ob alle Werte in der beschnittenen Version von enthalten sind x.

JavaScript (ES6), 60 Byte

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

Dies ist ein einfacher Algorithmus:

Iterieren Sie das Array in umgekehrter Reihenfolge, und stellen Sie sicher, dass jede Zahl (mit Ausnahme der ersten) um eins kleiner oder gleich einer bereits gesehenen Zahl ist.

Snippet:

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 Bytes

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

Probieren Sie es online!

Eine direkte Implementierung der Definition, bei gder die Elemente entfernt werden, wenn sie> = sind, als die Elemente rechts davon.

C #, 69 Bytes

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

Kurz gesagt:
s = Eingabe (n) Entspricht
dem Element s, wobei alle Elemente nach diesem Element (Skip (I) Ndex + 1 Elemente), der aktuelle Wert höher ist
zählt diese und , ob die Menge der erwarteten Menge entspricht ((max) imum Wert minus (min) imum) Anzahl von Zahlen

Probieren Sie es online!

JavaScript (ES6), 82 73 72 70 Byte

Gibt einen Booleschen Wert zurück.

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

Wie?

Wir iterieren auf jedem Element x des Eingabearrays a und verfolgen dabei den maximal angetroffenen Wert m und die Zahl -k von Werten, die nicht größer oder gleich einem Mitglied zu ihrer Rechten sind. Per Definition werden gültige Werte in streng aufsteigender Reihenfolge angezeigt.

Wir verwenden filter()stattdessen map(), damit alle Elemente herausgefiltert werden, bis k negativ wird. Auf diese Weise können wir das erste gültige Element isolieren, bei dem auch der Mindestwert des Arrays garantiert ist.

Schließlich testen wir, ob minimum - (maximum + 1) == -number_of_valid_elements:

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

Testfälle

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