Ceci est destiné à être un golf de code facile et de la taille d'une bouchée.

Le mex (nombre minimal exclu) d'une collection finie de nombres est le plus petit entier non négatif 0, 1, 2, 3, 4, ...qui n'apparaît pas dans la collection. En d'autres termes, c'est le minimum du complément. L'opération mex est au cœur de l'analyse des jeux impartiaux dans la théorie des jeux combinatoires .

Votre objectif est d'écrire un programme ou une fonction nommée pour calculer le mex en utilisant le moins d'octets possible.

Contribution:

Une liste d'entiers non négatifs dans n'importe quel ordre. Peut contenir des répétitions. Pour être concret, la longueur de la liste et la plage autorisée d'éléments seront à la fois comprises 0et 20inclusives.

La définition de "liste" ici est flexible. Toute structure qui représente une collection de nombres est très bien, tant qu'elle a un ordre fixe d'éléments et permet des répétitions. Il ne peut contenir aucune information auxiliaire à l'exception de sa longueur.

L'entrée peut être considérée comme un argument de fonction ou via STDIN.

Production

Le plus petit nombre exclu. Imprimez-le ou imprimez-le.

Cas de test

[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 octets

h-U21Q

Exemple d'exécution

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

Comment ça fonctionne

  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 octets

K),l~^1<

Comment ça fonctionne:

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"

Exemple d'entrée:

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

Production:

10

Essayez-le en ligne ici

J - 13 caractères

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

Actions très simples en J, et donc très difficiles à rendre plus petites.

i.@21crée une liste de 0 à 20 inclus. -.effectue set-soustrait l'entrée de cette liste. 0{prend le premier élément de ce qui reste, c'est-à-dire le plus petit nombre. f=:définit une fonction nommée. Au 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

Depuis la sortie de J806 en novembre 2017, une nouvelle syntaxe existe qui nous permet d'économiser un octet en nous permettant de l'utiliser i.@21pour l'ancien (i.21)dans ce contexte.

Golfscript 7

~21,^0=

Une version plus élaborée de la réponse de Peter Taylor. Wiki communautaire car je n'ai pas de représentant pour commenter son post.

La différence consiste à utiliser la taille de liste maximale connue de la question au lieu de la longueur +1 pour enregistrer un caractère et supprimer le $ non pertinent.

Essayez-le en ligne

Burlesque - 9 octets

20rzj\\<]

Prend l'entrée de stdin au format {7 6 5 5 1 2 2 4 2 0}

Expliqué:

 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.

Essayez quelques exemples:

{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 octets

seq 0 20|egrep -vwm1 $1

Cela suppose l'entrée en tant que |liste séparée par des canaux. Par exemple:

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

Rubis, 32 octets

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

Définit une fonction fà appeler avec un tableau.

GolfScript ( 10 9 octets)

~.,),^$0=

Prend l'entrée de stdin au format [5 4 1 5 4 8 2 1 5 4 0 7 7].

Démo en ligne

Xojo, 55 octets

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

Rubis, 22

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

Explication

• L'entrée est considérée comme un argument d'un lambda. Il s'attend à ce que l'un Arraydes Integerart.
• L'entrée est soustraite du tableau [0,1,2..20].
• Parce que le Array [0,1,2..20]est trié, le premier élément doit être le mex.

Haskell, 30

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

Cela fonctionne pour les listes de toutes tailles et les listes au-delà de 20. Cela peut être effectué sur 15 octets si Data.List est importé:

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

Schéma - 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))))

Pas très compétitif. Mais j'aime écrire un schéma :),

Voici le code non golfé:

(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 caractères

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

C # - 64 caractères

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

Pas toujours la meilleure langue de golf, mais facile à écrire et à comprendre :)

Scala, 18 octets

0 to 20 diff l min

l est une liste de 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 octets

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

Essayez-le en ligne!

Java 7, 69 66 octets

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

-3 octets grâce à @LeakyNun

Explication:

Prend en charge non seulement 0-20, mais 0-2147483647 à la place (ce qui économise en fait des octets).

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

Code de test:

Essayez-le ici.

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

Production:

0
1
1
2
0
0
3
4
4
10

APL (Dyalog) , 19 octets

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

Essayez-le en ligne!

Je manque probablement quelque chose d'important ici. Golf en cours ...

TI-BASIC, 24 octets

: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

Si Prompt Xest donné une liste au lieu d'un seul numéro, il créera automatiquement une liste nommée Xaccessible avec ʟX.

Stax , 6 octets

¢╔⌂♀╠▬

Exécuter et déboguer

Explication

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 octets

f←⊃⊢~⍨0,⍳∘⍴

Essayez-le en ligne!

Gelée , 7 octets

Une autre approche. Peut être utilisé dans une chaîne avec n'importe quelle arité, et n'a pas besoin de séparateur de chaîne ou quoi que ce soit.

‘Ṭ;0i0’

Étant donné que la réponse est garantie inférieure à 256, cela fonctionne également:

Gelée , 5 octets

⁹ḶḟµḢ

Essayez-le en ligne!

Powershell, 28 octets

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

Script de test:

$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"
}

Production:

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

Explication:

• Incrémenter $ipendant que le $argstableau contient la valeur entière +$i.
• Affiche une dernière valeur entière +$i.

MathGolf , 5 4 octets

Jr,╓

Essayez-le en ligne!

Cette solution est limitée à la plage de 0 à 20, bien qu'elle puisse être étendue facilement en augmentant la plage initiale.

Explication:

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

Alternativement, une solution à 5 octets pour tous les nombres:

Åï╧▲ï

Essayez-le en ligne!

Explication:

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

Perl - 34

Voici un sous-programme.

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

Testez avec:

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

Non golfé:

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)

Agréable et simple! Notez la boucle while vide.

JavaScript (E6) 35

Fonction récursive, paramètre de tableau en entrée et retour du mex. Pas limité à 20

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

Test dans la console FireFox / FireBug

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

Production

[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 octets

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

PHP, 39 octets

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