Bu, kolay, ısırık büyüklüğünde bir kod golfü olarak tasarlanmıştır.

Mex sayıların sonlu toplama (minimum hariç numara) en küçük negatif olmayan tamsayıdır 0, 1, 2, 3, 4, ...yok değil koleksiyonunda görünür. Başka bir deyişle, tamamlayıcı minimumdur. Mex operasyon analizi merkezidir tarafsız oyunlarda yer kombinatoryal oyun teorisi .

Amacınız , mümkün olduğunca az bayt kullanarak mex'i hesaplamak için bir program veya adlandırılmış işlev yazmaktır .

Giriş:

Herhangi bir sırada negatif olmayan tam sayıların listesi. Tekrar içerebilir. Kesinleştirmek için, liste uzunluğu ve elemanların izin aralığı her iki arasında olacaktır 0ve 20dahildir.

Burada "liste" tanımı esnektir. Bir sayı koleksiyonunu temsil eden herhangi bir yapı, öğelerin sabit bir sırasına sahip olduğu ve tekrarlara izin verdiği sürece iyidir. Uzunluğu dışında herhangi bir yardımcı bilgi içermeyebilir.

Giriş bir işlev bağımsız değişkeni olarak veya STDIN aracılığıyla alınabilir.

Çıktı

Hariç tutulan en küçük sayı. Çıktı alın veya yazdırın.

Test senaryoları

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

h-U21Q

Örnek çalışma

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

Nasıl çalışır

  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 bayt

K),l~^1<

Nasıl çalışır:

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"

Örnek giriş:

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

Çıktı:

10

Buradan çevrimiçi deneyin

J - 13 karakter

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

J'de çok basit eylemler ve dolayısıyla daha küçük yapmak çok zor.

i.@210 ile 20 (dahil) arasında bir liste oluşturur. -.girişi bu listeden alır-çıkarır. 0{kalanın ilk öğesini, yani en küçük sayıyı alır. f=:adlandırılmış bir işlevi tanımlar. REPL'de:

   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

J806'nın Kasım 2017'de piyasaya sürülmesinden bu yana, bu bağlamda i.@21yaşlılar için kullanmamıza izin vererek bizi bir bayt tasarruf eden yeni bir sözdizimi var (i.21).

Golf Yazıları 7

~21,^0=

Peter Taylor'ın cevabının daha golf edilmiş bir versiyonu. Topluluk wiki beri onun yazı üzerine yorum temsilcisi yok.

Aradaki fark, bir karakteri kaydetmek ve alakasız $ 'ı düşürmek için uzunluk +1 yerine sorudan bilinen maksimum liste boyutunu kullanmaktır.

Çevrimiçi deneyin

Burlesque - 9 Bayt

20rzj\\<]

Stdin'den {7 6 5 5 1 2 2 4 2 0} formatında girdi alır

Açıklaması:

 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.

Bazı örnekleri deneyin:

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

seq 0 20|egrep -vwm1 $1

Bu, girişin |(boru) ayrılmış bir liste olduğunu varsayar . Örneğin:

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

Ruby, 32 bayt

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

fBir dizi ile çağrılacak bir işlevi tanımlar .

GolfScript ( 10 9 bayt)

~.,),^$0=

Stdin'den formatta girdi alır [5 4 1 5 4 8 2 1 5 4 0 7 7].

Çevrimiçi demo

Xojo, 55 bayt

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

Ruby, 22

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

açıklama

• Girdi bir lambda'ya argüman olarak alınır. Bir beklediğini Arrayait Integers.
• Giriş diziden çıkarılır [0,1,2..20].
• Sıralandığından, Array [0,1,2..20]ilk öğe meks olmalıdır.

Haskell, 30

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

Bu, tüm boyuttaki listeler ve 20'nin üzerindeki listeler için çalışır. Bu, Data.List içe aktarılırsa 15 bayt uzunluğunda yapılabilir:

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

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

Çok rekabetçi değil. Ama şema yazmayı seviyorum :),

İşte kodlanmamış kod:

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

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

64 karakter

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

Her zaman değil Nadiren en iyi golf dili, ancak yazmak ve anlamak kolaydır :)

Scala, 18 bayt

0 to 20 diff l min

l Int listesidir.

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 bayt

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

Çevrimiçi deneyin!

Java 7, 69 66 bayt

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

@LeakyNun sayesinde -3 bayt

Açıklama:

Sadece 0-20 değil, 0-2147483647'yi de destekler (bu aslında bayt tasarrufu sağlar).

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

Test kodu:

Burada deneyin.

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

Çıktı:

0
1
1
2
0
0
3
4
4
10

APL (Dyalog) , 19 bayt

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

Çevrimiçi deneyin!

Muhtemelen burada önemli bir şeyi kaçırıyorum. Golf devam ediyor ...

TI-BASIC, 24 bayt

: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

Tek Prompt Xbir numara yerine bir liste verilirse, otomatik Xolarak erişilebilen bir liste oluşturur ʟX.

Stax , 6 bayt

¢╔⌂♀╠▬

Çalıştır ve hata ayıkla

açıklama

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 Klasik) , 11 bayt

f←⊃⊢~⍨0,⍳∘⍴

Çevrimiçi deneyin!

Jöle , 7 bayt

Başka bir yaklaşım. Herhangi bir çapa sahip bir zincirde kullanılabilir ve zincir ayırıcıya veya herhangi bir şeye ihtiyaç duymaz.

‘Ṭ;0i0’

Cevabın 256'dan az olduğu garanti edildiğinden, bu da işe yarar:

Jöle , 5 bayt

⁹ḶḟµḢ

Çevrimiçi deneyin!

Powershell, 28 bayt

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

Test komut dosyası:

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

Çıktı:

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

Açıklama:

• Arttırır $iise $argsdizi tam sayı değeri içerir +$i.
• Son bir tamsayı değeri çıktılar +$i.

MathGolf , 5 4 bayt

Jr,╓

Çevrimiçi deneyin!

Bu çözüm sadece 0 ila 20 aralığıyla sınırlıdır, ancak bu başlangıç ​​aralığı artırılarak kolayca genişletilebilir.

Açıklama:

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

Alternatif olarak, tüm sayılar için 5 baytlık bir çözüm:

Åï╧▲ï

Çevrimiçi deneyin!

Açıklama:

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

Perl - 34

İşte bir altyordam.

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

Şununla test et:

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

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

Güzel ve basit! Boş while döngüsüne dikkat edin.

JavaScript (E6) 35

Özyinelemeli işlev, girişte dizi parametresi ve döndürme mex. 20 ile sınırlı değil

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

FireFox / FireBug konsolunda test

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

Çıktı

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

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

PHP, 39 Bayt

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