Dies soll ein einfacher, mundgerechter Code-Golf sein.

Das mex (minimale ausgeschlossene Zahl) einer endlichen Auflistung von Zahlen ist die kleinste nicht negative Ganzzahl 0, 1, 2, 3, 4, ..., die nicht in der Auflistung enthalten ist. Mit anderen Worten, es ist das Minimum des Komplements. Die mex-Operation spielt eine zentrale Rolle bei der Analyse unparteiischer Spiele in der kombinatorischen Spieltheorie .

Ihr Ziel ist es, ein Programm oder eine benannte Funktion zu schreiben , um den mex mit möglichst wenigen Bytes zu berechnen.

Eingang:

Eine Liste nicht negativer Ganzzahlen in beliebiger Reihenfolge. Kann Wiederholungen enthalten. Der Vollständigkeit halber werden die Länge der Liste und der zulässige Bereich von Elementen sowohl zwischen 0als auch 20einschließlich liegen.

Die Definition von "Liste" ist hier flexibel. Jede Struktur, die eine Sammlung von Zahlen darstellt, ist in Ordnung, solange sie eine feste Reihenfolge von Elementen aufweist und Wiederholungen zulässt. Sie darf außer ihrer Länge keine zusätzlichen Informationen enthalten.

Die Eingabe kann als Funktionsargument oder über STDIN erfolgen.

Ausgabe

Die kleinste ausgeschlossene Zahl. Ausgeben oder ausdrucken.

Testfälle

[1]
0
[0]
1
[2, 0]
1
[3, 1, 0, 1, 3, 3]
2
[]
0
[1, 2, 3]
0
[5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7]
3
[3, 2, 1, 0]
4
[0, 0, 1, 1, 2, 2, 3]
4
[1, 0, 7, 6, 3, 11, 15, 1, 9, 2, 3, 1, 5, 2, 3, 4, 6, 8, 1, 18]
10

Pyth , 6 Bytes

h-U21Q

Beispiellauf

$ pyth -c h-U21Q <<< '[5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7]'
3

Wie es funktioniert

  U21   range(21)
     Q  eval(input())
 -U21Q  setwisedifference(range(21), eval(input))          # Pyth function. Preserves order.
h-U21Q  setwisedifference(range(21), eval(input))[0]

CJam, 11 8 Bytes

K),l~^1<

Wie es funktioniert:

K),         "Create an array with numbers 0 through 20"
   l~       "Read the input and eval it, resulting to an array"
     ^      "XOR the elements of two arrays, resulting in a complement array"
      1<    "Take the first element of the resultant array"

Beispieleingabe:

[1 0 7 6 3 11 15 1 9 2 3 1 5 2 3 4 6 8 1 18]

Ausgabe:

10

Probieren Sie es hier online aus

J - 13 Zeichen

f=:0{i.@21&-.

Sehr einfache Aktionen in J und daher sehr schwer zu verkleinern.

i.@21Erstellt eine Liste von 0 bis einschließlich 20. -.führt set-subtrahiert die Eingabe von dieser Liste aus. 0{Nimmt das erste Element von dem, was übrig ist, dh die kleinste Zahl. f=:definiert eine benannte Funktion. Auf der REPL:

   f=:0{(i.21)&-.
   f 1
0
   f 0
1
   f 2 0
1
   f 3 1 0 1 3 3
2
   f ''    NB. empty list
0
   f 1 2 3
0
   f 5 4 1 5 4 8 2 1 5 4 0 7 7
3
   f 3 2 1 0
4
   f 0 0 1 1 2 2 3
4
   f 1 0 7 6 3 11 15 1 9 2 3 1 5 2 3 4 6 8 1 18
10

Seit dem Release von J806 im November 2017 gibt es eine neue Syntax, die uns ein Byte erspart, indem wir in diesem Kontext i.@21die alte verwenden (i.21)können.

Golfscript 7

~21,^0=

Eine weitergehende Version von Peter Taylors Antwort. Community-Wiki, da ich nicht den Repräsentanten habe, der seinen Beitrag kommentiert.

Der Unterschied besteht darin, dass anstelle der Länge +1 die bekannte maximale Listengröße aus der Frage verwendet wird, um ein Zeichen zu speichern und das irrelevante $ zu löschen.

Probieren Sie es online aus

Burlesque - 9 Bytes

20rzj\\<]

Übernimmt die Eingabe von stdin im Format {7 6 5 5 1 2 2 4 2 0}

Erklärt:

 20 rz   map a range from 0 to 20. (thanks to algorithmshark for the cocde fix)
  j \\    swaps the two arrays, and collects the difference between the two into a new array
  <]      gets the smallest element of the resulting array.

Probieren Sie einige Beispiele aus:

{1 0 7 6 3 11 15 1 9 2 3 1 5 2 3 4 6 8 1 18} 20rzj \\ <]

{5 4 1 5 4 8 2 1 5 4 0 7 7} 20rzj \\ <]

Bash + Coreutils, 23 Bytes

seq 0 20|egrep -vwm1 $1

Dies setzt die Eingabe als |(Pipe-) getrennte Liste voraus . Z.B:

$ ./mex.sh "5|4|1|5|4|8|2|1|5|4|0|7|7"
3
$

Ruby, 32 Bytes

f=->n{(0..20).find{|i|n-[i]==n}}

Definiert eine Funktion f, die mit einem Array aufgerufen werden soll.

GolfScript ( 10 9 Bytes)

~.,),^$0=

Übernimmt die Eingabe von stdin im Format [5 4 1 5 4 8 2 1 5 4 0 7 7].

Online-Demo

Xojo, 55 Bytes

dim x as int8
while a.indexOf(x)>-1
x=x+1
wend
return x

Rubin, 22

x=->n{([*0..20]-n)[0]}

Erläuterung

• Die Eingabe wird als Argument für ein Lambda verwendet. Es erwartet einen Arrayvon Integers.
• Die Eingabe wird vom Array abgezogen [0,1,2..20].
• Da das Array [0,1,2..20]sortiert ist, muss das erste Element das mex sein.

Haskell, 30

f s=filter(`notElem`s)[0..]!!0

Dies funktioniert für Listen aller Größen und Listen jenseits von 20. Dies kann zu einer Länge von 15 Byte gemacht werden, wenn Data.List importiert wird:

f s=[0..]\\s!!0

Schema - 219

(define (A X) (define (B X) (if (equal? (length X) 1) (+ (car X) 1) (if (< (- (cadr X) (car X)) 2) (B (cdr X)) (+ (car X) 1)))) (if (empty? X) `() (if (equal? (car (sort X <)) 0) (B (sort X <)) (- (car (sort X <)) 1))))

Nicht sehr wettbewerbsfähig. Aber ich schreibe gerne Schema :),

Hier ist der ungolfed Code:

(define (minExclude X)
  (define (firstNonOneDifference X)
     (if (equal? (length X) 1)
         (+ (car X) 1)
     (if (< (- (cadr X) (car X)) 2) 
         (firstNonOneDifference (cdr X))
         (+ (car X) 1)
     ))
  )
  (let ([s (sort X <)])
     (if (empty? X)
         `()
     (if (equal? (car s) 0)
        (firstNonOneDifference s)
        (- (car s) 1)
     ))
  )
)

Python, 37 Zeichen

f=lambda a:min(set(range(21))-set(a))

C # - 64 Zeichen

int f(int[] a){return Enumerable.Range(0,20).Except(a).First();}

Nicht immer Selten die beste Golfsprache, aber einfach zu schreiben und zu verstehen :)

Scala, 18 Bytes

0 to 20 diff l min

l ist eine Liste von Int.

scala> val l = List(0,1,5)
l: List[Int] = List(0, 1, 5)

scala> 0 to 20 diff l min
res0: Int = 2

Java , 91 Bytes

int f(int[]a){int i=0,j=1,k;for(;j>0;i++)for(k=j=0;k<a.length;j=a[k++]==i?1:j);return i-1;}

Probieren Sie es online!

Java 7, 69 66 Bytes

int c(java.util.List a){int r=0;for(;a.contains(r);r++);return r;}

-3 Bytes dank @LeakyNun

Erläuterung:

Unterstützt stattdessen nicht nur 0-20, sondern 0-2147483647 (was tatsächlich Bytes spart).

int c(java.util.List a){    // Method with List parameter and integer return-type
  int r=0;                  //  Return integer
  for(;a.contains(r);r++);  //  Continue raising `r` as long as the list contains the current `r`
  return r;                 //  Return result-integer
}                           // End of method

Testcode:

Probieren Sie es hier aus.

import java.util.ArrayList;
import java.util.Arrays;
class M{
  static int c(java.util.List a){int r=0;for(;a.contains(r);r++);return r;}

  public static void main(String[] a){
    System.out.println(c(Arrays.asList(1)));
    System.out.println(c(Arrays.asList(0)));
    System.out.println(c(Arrays.asList(2, 0)));
    System.out.println(c(Arrays.asList(3, 1, 0, 1, 3, 3)));
    System.out.println(c(new ArrayList()));
    System.out.println(c(Arrays.asList(1, 2, 3)));
    System.out.println(c(Arrays.asList(5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7)));
    System.out.println(c(Arrays.asList(3, 2, 1, 0)));
    System.out.println(c(Arrays.asList(0, 0, 1, 1, 2, 2, 3)));
    System.out.println(c(Arrays.asList(1, 0, 7, 6, 3, 11, 15, 1, 9, 2, 3, 1, 5, 2, 3, 4, 6, 8, 1, 18)));
  }
}

Ausgabe:

0
1
1
2
0
0
3
4
4
10

APL (Dyalog) , 19 Bytes

(0⍳⍨⊢=⍳∘⍴)∘(⊂∘⍋⌷⊢)∪

Probieren Sie es online!

Ich vermisse hier wahrscheinlich etwas Wichtiges. Golfen im Gange ...

TI-BASIC, 24 Byte

:0→A                 //Store 0 to A
:Prompt X            //Prompt list X
:While not(prod(ʟX-A //While A is not missing from list X
:A+1→A               //Increment A
:End                 //End While loop
:A                   //Print A

Wenn Prompt Xanstelle einer einzelnen Nummer eine Liste angegeben wird, wird automatisch eine Liste mit dem Namen erstellt X, auf die zugegriffen werden kann ʟX.

Stax , 6 Bytes

¢╔⌂♀╠▬

Führen Sie es aus und debuggen Sie es

Erläuterung

21r:IUI             # Full program, unpacked
21                  # Push 21
  r                 # Range from 0...20
   :I               # Find all elements in input that exist in range
    U               # push -1
     I              # Get index of first occurrence of

APL (Dyalog Classic) , 11 Bytes

f←⊃⊢~⍨0,⍳∘⍴

Probieren Sie es online!

Gelee , 7 Bytes

Ein anderer Ansatz. Kann in einer Kette beliebiger Art verwendet werden und benötigt keinen Kettentrenner oder ähnliches.

‘Ṭ;0i0’

Da die Antwort garantiert weniger als 256 ist, funktioniert dies auch:

Gelee , 5 Bytes

⁹ḶḟµḢ

Probieren Sie es online!

Powershell, 28 Bytes

for(;+$i-in$args){$i++}+$i

Testskript:

$f = {
 for(;+$i-in$args){$i++}+$i
#for(;$i++-in$args){}(--$i)   # alternative version
}

@(
    ,(0 , 1)
    ,(1 , 0)
    ,(2 , 3, 1, 0, 1, 3, 3)
    ,(0 )
    ,(0 , 1, 2, 3)
    ,(3 , 5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7)
    ,(4 , 3, 2, 1, 0)
    ,(4 , 0, 0, 1, 1, 2, 2, 3)
    ,(10, 1, 0, 7, 6, 3, 11, 15, 1, 9, 2, 3, 1, 5, 2, 3, 4, 6, 8, 1, 18)
) | % {
    $e, $a = $_
    $r = &$f @a
    "$($r-eq$e): $r"
}

Ausgabe:

True: 0
True: 1
True: 2
True: 0
True: 0
True: 3
True: 4
True: 4
True: 10

Erläuterung:

• Inkrementieren Sie, $iwährend das $argsArray den ganzzahligen Wert enthält+$i .
• Gibt einen letzten ganzzahligen Wert aus +$i.

MathGolf , 5 4 Bytes

Jr,╓

Probieren Sie es online!

Diese Lösung ist auf den Bereich von 0 bis 20 beschränkt, kann jedoch durch Erhöhen des Anfangsbereichs problemlos erweitert werden.

Erläuterung:

Jr     Range from 0 to 20
  ,    Remove elements from the input list from this range
   ╓   Return the minimum element

Alternativ eine 5-Byte-Lösung für alle Zahlen:

Åï╧▲ï

Probieren Sie es online!

Erläuterung:

Å  ▲   Do while true
  ╧    Does the input contain
 ï     The index of the loop?
    ï  Push the number of iterations of the last loop

Perl - 34

Hier ist eine Unterroutine.

sub f{$_~~@_?1:return$_ for0..20}

Testen Sie mit:

perl -e'print f(0,1,3,4,5,6,7); sub f{$_~~@_?1:return$_ for 0..20}'

Java, 93

int f(int[]a){int i=0,j=0,k=a.length;for(;i++<20&j<k;){for(j=0;j<k&&a[j++]!=i;);}return i-1;}

Ungolfed:

int f(int[] a) {
    int i = 0, j = 0, length = a.length;
    for (; i < 20 & j < length; i++) {
        for (j = 0; j < length && a[j] != i; j++) { }
    }
    return i - 1;
}

Cobra - 50

def f(l)
    for n in 22,if n not in l,break
    print n

Javascript, 74

i=-1;a=prompt().split(',');while(i<21&&a.indexOf(String(++i))>=0);alert(i)

Schön und einfach! Beachten Sie die leere while-Schleife.

JavaScript (E6) 35

Rekursive Funktion, Array-Parameter in Eingabe und Rückgabe der mex. Nicht auf 20 begrenzt

F=(l,i=0)=>~l.indexOf(i)?F(l,++i):i

Test in der FireFox / FireBug-Konsole

;[[1],[0],[2, 0],[3, 1, 0, 1, 3, 3],[],[1, 2, 3],
[5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7],[3, 2, 1, 0],[0, 0, 1, 1, 2, 2, 3],
[1, 0, 7, 6, 3, 11, 15, 1, 9, 2, 3, 1, 5, 2, 3, 4, 6, 8, 1, 18]]
.forEach(list => console.log(list, F(list)))

Ausgabe

[1] 0
[0] 1
[2, 0] 1
[3, 1, 0, 1, 3, 3] 2
[] 0
[1, 2, 3] 0
[5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7] 3
[3, 2, 1, 0] 4
[0, 0, 1, 1, 2, 2, 3] 4
[1, 0, 7, 6, 3, 11, 15, 1, 9, 2, 3, 1, 5, 2, 3, 4, 6, 8, 1, 18] 10

PHP, 38 Bytes

<?=min(array_diff(range(0,20),$_GET));

PHP, 39 Bytes

<?for(;in_array($i++,$_GET););echo$i-1;