Questo è inteso per essere un codice-golf facile e di dimensioni ridotte.

Il mex (numero minimo escluso) di una raccolta finita di numeri è il numero intero non negativo più piccolo 0, 1, 2, 3, 4, ...che non appare nella raccolta. In altre parole, è il minimo del complemento. L'operazione mex è fondamentale per l'analisi dei giochi imparziali nella teoria dei giochi combinatoria .

Il tuo obiettivo è quello di scrivere un programma o una funzione con nome per calcolare il Messico usando il minor numero di byte possibile.

Ingresso:

Un elenco di numeri interi non negativi in ​​qualsiasi ordine. Può contenere ripetizioni. Per concretezza, la lunghezza dell'elenco e la gamma consentita di elementi sarà sia compresa 0che compresa 20.

La definizione di "elenco" qui è flessibile. Qualsiasi struttura che rappresenta una raccolta di numeri va bene, purché abbia un ordinamento fisso di elementi e consenta la ripetizione. Non può includere alcuna informazione ausiliaria tranne la sua lunghezza.

L'input può essere preso come argomento di funzione o tramite STDIN.

Produzione

Il numero escluso più piccolo. Uscita o stampa.

Casi 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 byte

h-U21Q

Esempio di esecuzione

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

Come funziona

  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 byte

K),l~^1<

Come funziona:

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"

Input di esempio:

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

Produzione:

10

Provalo online qui

J - 13 caratteri

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

Azioni molto semplici in J, e quindi molto difficili da ridurre.

i.@21crea un elenco da 0 a 20 inclusi. -.esegue set-sottrae l'input da questo elenco. 0{prende il primo elemento di ciò che resta, ovvero il numero più piccolo. f=:definisce una funzione denominata. Alla 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

Dal rilascio di J806 nel novembre 2017, esiste una nuova sintassi che ci consente di risparmiare un byte permettendoci di utilizzare i.@21il vecchio (i.21)in questo contesto.

Golfscript 7

~21,^0=

Una versione ulteriormente approfondita della risposta di Peter Taylor. Wiki della community poiché non ho il rappresentante per commentare il suo post.

La differenza sta usando la dimensione massima dell'elenco nota dalla domanda invece della lunghezza +1 per salvare un carattere e far cadere $ irrilevante.

Provalo online

Burlesque - 9 byte

20rzj\\<]

Accetta input da stdin nel formato {7 6 5 5 1 2 2 4 2 0}

Ha spiegato:

 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.

Prova alcuni esempi:

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

seq 0 20|egrep -vwm1 $1

Ciò presuppone l'input come un |elenco separato (pipe). Per esempio:

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

Rubino, 32 byte

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

Definisce una funzione fda chiamare con un array.

GolfScript ( 10 9 byte)

~.,),^$0=

Prende input da stdin nel formato [5 4 1 5 4 8 2 1 5 4 0 7 7].

Demo online

Xojo, 55 byte

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

Ruby, 22

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

Spiegazione

• L'input viene preso come argomento per un lambda. Si aspetta unArray di Integers.
• L'input viene sottratto dall'array [0,1,2..20] .
• Poiché Array [0,1,2..20]viene ordinato, il primo elemento deve essere il mex.

Haskell, 30 anni

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

Funziona con elenchi di tutte le dimensioni e con elenchi oltre 20. Questo può essere lungo 15 byte se DataList viene importato:

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

Non molto competitivo. Ma mi piace scrivere schemi :),

Ecco il codice non salvato:

(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 personaggi

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

C # - 64 caratteri

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

Non sempre Raramente il miglior linguaggio per giocare a golf, ma è facile da scrivere e capire :)

Scala, 18 byte

0 to 20 diff l min

l è un elenco di 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 byte

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

Provalo online!

Java 7, 69 66 byte

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

-3 byte grazie a @LeakyNun

Spiegazione:

Supporta non solo 0-20, ma invece 0-2147483647 (che in realtà salva i byte).

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

Codice di prova:

Provalo qui.

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

Produzione:

0
1
1
2
0
0
3
4
4
10

APL (Dyalog) , 19 byte

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

Provalo online!

Probabilmente mi sto perdendo qualcosa di importante qui. Giocare a golf in corso ...

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

Se Prompt Xviene fornito un elenco anziché un singolo numero, verrà automaticamente creato un elenco denominato a Xcui è possibile accedere ʟX.

Stax , 6 byte

¢╔⌂♀╠▬

Esegui ed esegui il debug

Spiegazione

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 byte

f←⊃⊢~⍨0,⍳∘⍴

Provalo online!

Gelatina , 7 byte

Un altro approccio. Può essere usato in una catena con qualsiasi arità e non ha bisogno del separatore di catena o altro.

‘Ṭ;0i0’

Poiché la risposta è garantita per essere inferiore a 256, funziona anche:

Gelatina , 5 byte

⁹ḶḟµḢ

Provalo online!

Powershell, 28 byte

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

Script di prova:

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

Produzione:

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

Spiegazione:

• Incrementa $imentre l' $argsarray contiene il valore intero +$i.
• Emette un ultimo valore intero +$i.

MathGolf , 5 4 byte

Jr,╓

Provalo online!

Questa soluzione è limitata solo all'intervallo da 0 a 20, sebbene possa essere estesa facilmente aumentando l'intervallo iniziale.

Spiegazione:

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

In alternativa, una soluzione a 5 byte per tutti i numeri:

Åï╧▲ï

Provalo online!

Spiegazione:

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

Perl - 34

Ecco una subroutine.

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

Prova con:

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)

Bello e semplice! Nota il ciclo while vuoto.

JavaScript (E6) 35

Funzione ricorsiva, parametro array in input e restituzione di mex. Non limitato a 20

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

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

Produzione

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

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

PHP, 39 byte

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