14

यह एक आसान, काटने के आकार का कोड-गोल्फ होने का इरादा है।

MEX संख्या की एक निश्चित संग्रह का (न्यूनतम बाहर रखा संख्या) सबसे छोटी गैर नकारात्मक पूर्णांक है 0, 1, 2, 3, 4, ...कि है नहीं संग्रह में दिखाई देते हैं। दूसरे शब्दों में, यह पूरक का न्यूनतम है। मेक्सिको ऑपरेशन कॉम्बिनेटरियल गेम सिद्धांत में निष्पक्ष गेम के विश्लेषण के लिए केंद्रीय है ।

आपका लक्ष्य संभव के रूप में कुछ बाइट्स का उपयोग करके मेक्सिको की गणना करने के लिए एक प्रोग्राम या नामित फ़ंक्शन लिखना है।

इनपुट:

किसी भी क्रम में गैर-नकारात्मक पूर्णांक की एक सूची। दोहराए जा सकते हैं। संक्षिप्तता के लिए, सूची की लंबाई और तत्वों की अनुमत सीमा दोनों के बीच 0और 20समावेशी होगी।

यहाँ "सूची" की परिभाषा लचीली है। कोई भी संरचना जो संख्याओं के संग्रह का प्रतिनिधित्व करती है, ठीक है, जब तक कि इसमें तत्वों का एक निश्चित क्रम होता है और दोहराता है। इसमें इसकी लंबाई को छोड़कर कोई भी सहायक जानकारी शामिल नहीं हो सकती है।

इनपुट को फ़ंक्शन तर्क के रूप में या STDIN के माध्यम से लिया जा सकता है।

उत्पादन

सबसे छोटी बहिष्कृत संख्या। इसे आउटपुट या प्रिंट करें।

परीक्षण के मामलों

[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

code-golf math

— XNOR
स्रोत

2

संख्याओं को एक निश्चित सीमा तक सीमित करने से यह समस्या और भी सरल हो जाती है।

— मार्टिन एंडर

@ MartinBüttner सरणी सभी संख्या शामिल है 0के लिए 20, सही उत्पादन 21. मैं एक परीक्षण का मामला जोड़ देंगे है। हां, निश्चित सीमा निश्चित रूप से इसे आसान बनाती है, हालांकि कोई अभी भी यकीनन उपयोग sys.maxintकर सकता है या 2**64यदि मैंने इसे निर्दिष्ट नहीं किया है।

— 21

उस टेस्ट केस की कोई जरूरत नहीं। आपने कहा, इनपुट में केवल 21 तत्व हो सकते हैं।

— मार्टिन एंडर

@ मार्टिनबटनर राइट, बाड़पोस्ट। धन्यवाद।

— 21

1

@ केविनफैगन हाँ, अधिकतम संभव उत्पादन 20 है। मेरी टिप्पणी गलत थी और मुझे लगता है कि मार्टिनबटनर टाइपो थे।

— xnor

11

अजगर , 6 बाइट्स

h-U21Q

उदाहरण चलाते हैं

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

यह काम किस प्रकार करता है

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

— डेनिस
स्रोत

जब सेट को सूची में बदल दिया जाता है, तो क्या यह हमेशा क्रमबद्ध क्रम में होता है?

— xnor

पायथ का सेट अंतर पहले तर्क ( range(21)) के आदेश को संरक्षित करता है , जिसे आदेश दिया गया है। (इसका मतलब यह भी है कि स्पष्टीकरण पूरी तरह से सटीक नहीं है। पायथ और पायथन 3 दोनों मेरे लिए काफी नए हैं।)

— डेनिस

1

स्पष्ट करने के लिए, -पायथ वास्तव में एक फिल्टर है - यह दूसरे तर्क से अनुपस्थिति के लिए पहले तर्क को फ़िल्टर करता है, फिर इसे पहले तर्क (स्ट्रिंग, सूची या सेट) के रूप में परिवर्तित करता है।

— isaacg

इसके अलावा, डेनिस, ऐसा होना चाहिए h-U22Qताकि यह पूर्ण स्वीकार्य सीमा वाले इनपुट पर 21 का सही आउटपुट दे।

— isaacg

@ लिसाक: सूची की लंबाई भी 20 तक सीमित है, इसलिए इसमें 0 से 20 तक सभी 21 नंबर नहीं हो सकते हैं।

— डेनिस

6

सीजेएम, 11 8 बाइट्स

K),l~^1<

यह काम किस प्रकार करता है:

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"

नमूना इनपुट:

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

आउटपुट:

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

CJam में एकल-वर्ण संख्या कितनी अधिक है?

— xnor

@ एक्सनॉर सैडली, 20 - sourceforge.net/p/cjam/wiki/Variables

— ऑप्टिमाइज़र

एक भाग्यशाली विकल्प!

— xnor

5

जे - 13 चार

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

जे में बहुत सरल क्रियाएं, और इस प्रकार छोटे बनाने के लिए बहुत कठिन है।

i.@210 से 20 तक की सूची बनाता है। -.इस सूची से इनपुट को सेट-घटाता है। 0{जो बचा है उसका पहला तत्व लेता है, यानी सबसे छोटी संख्या। f=:एक नामित कार्य को परिभाषित करता है। 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

नवंबर 2017 में J806 की रिहाई के बाद से, एक नया वाक्यविन्यास मौजूद है जो हमें इस संदर्भ में i.@21पुराने के लिए उपयोग करने से एक बाइट बचाता है (i.21)।

— algorithmshark
स्रोत

क्या आपको जरूरत है f=:?

— फल तोड़ना

नवंबर 2017 से i.@21-.]1 बाइट की बचत होगी।

— FrownyFrog

4

गोल्फक्राफ्ट 7

~21,^0=

पीटर टेलर के उत्तर का एक और गोल्फ संस्करण। सामुदायिक विकी क्योंकि मुझे उनके पोस्ट पर टिप्पणी करने का रेप नहीं है।

अंतर एक चरित्र को बचाने और अप्रासंगिक $ को छोड़ने के लिए लंबाई +1 के बजाय प्रश्न से ज्ञात अधिकतम सूची आकार का उपयोग कर रहा है।

इसे ऑनलाइन आज़माएं

— paradigmsort
स्रोत

1

1 वर्ण को बचाने के लिए डेमिट गोल्फस्कैप

— ऑप्टिमाइज़र

4

बर्लेस्क - 9 बाइट्स

20rzj\\<]

प्रारूप में स्टड से इनपुट लेता है {7 6 5 5 1 2 2 4 2 0}

व्याख्या की:

 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.

कुछ उदाहरण आज़माएँ:

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

{५ ४ १ १ ५ ४ 1 २ १ ५ ४ 4 r} २०rzj \\ <]

— AndoDaan
स्रोत

1

यह इनपुट पर किसी भी आउटपुट देने में विफल रहता है {0 1 2}, क्योंकि आपको rzसबसे बड़ी संख्या से अधिक की आवश्यकता है । बस 20rzj\\<]इसे ठीक करने के लिए सीधे जा रहा है और एक चार बचाता है।

— एल्गोरिद्मशार्क

@al एल्गोरिदम इसके आसपास कोई रास्ता नहीं है, आप बहुत सही हैं। फिक्स्ड। और धन्यवाद।

— अंदोअन

3

बैश + कोरुटिल्स, 23 बाइट्स

seq 0 20|egrep -vwm1 $1

यह इनपुट |(पाइप) अलग सूची के रूप में मानता है । उदाहरण के लिए:

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

— डिजिटल आघात
स्रोत

1

मुझे नहीं लगता कि आपको इसकी आवश्यकता "(...)"है $1।

— डेनिस

1

पाइप-पृथक ठीक है, यह कल्पना की सूची जैसी स्थिति से मिलता है।

— xnor

2

रूबी, 32 बाइट्स

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

किसी फ़ंक्शन fको एक सरणी के साथ बुलाया जाना परिभाषित करता है ।

— मार्टिन एंडर
स्रोत

डाउनवॉटर से कोई टिप्पणी? क्या मुझे कल्पना का कुछ हिस्सा याद था?

— मार्टिन एंडर

मुझे शक है। कई अन्य जवाबों (मेरा सहित) को एक रहस्य है।

— ग्रेग हेवगिल सेप

@ipi लेकिन यह करता है ... वास्तव में चुनौती पदों में उदाहरणों में दिए गए प्रारूप में, उदाहरण के लिए f[[0, 1]](जहां बाहरी कोष्ठक आह्वान वाक्यविन्यास हैं और आंतरिक कोष्ठक सरणी को परिभाषित करते हैं)।

— मार्टिन एंडर

आपको इसकी आवश्यकता क्यों है f=?

— फलदायी फल

2

GolfScript ( 10 9 बाइट्स)

~.,),^$0=

प्रारूप में स्टडिन से इनपुट लेता है [5 4 1 5 4 8 2 1 5 4 0 7 7]।

ऑनलाइन डेमो

— पीटर टेलर
स्रोत

क्या ;प्रोग्राम में इनपुट स्ट्रिंग को पहले ही नहीं गिना जाना चाहिए?

— अनुकूलक

1

@ ऑप्टिमाइज़र, वह स्टड से इनपुट का अनुकरण कर रहा है क्योंकि ऑनलाइन गोल्फस्क्रिप्ट साइट एक अलग इनपुट फ़ील्ड का समर्थन नहीं करती है।

— पीटर टेलर

2

ज़ोजो, 55 बाइट्स

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

— silverpie
स्रोत

2

रूबी, २२

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

व्याख्या

इनपुट को एक लंबोदर के तर्क के रूप में लिया जाता है। यह एक Arrayकी उम्मीद है Integer।
इनपुट को सरणी से घटाया गया है [0,1,2..20]।
क्योंकि Array [0,1,2..20]क्रमबद्ध है, पहला तत्व मेक्सिको होना चाहिए।

— britishtea
स्रोत

स्वीट, यह मेरा पहला प्रयास था, लेकिन मुझे काम करने के लिए विनाशकारी नहीं मिला - मैंने इसे कोष्ठक के साथ घेरने के बारे में नहीं सोचा। Btw, आप 20इसके बजाय का उपयोग कर सकते हैं 21, क्योंकि इनपुट में केवल 20 तत्व हो सकते हैं।

— मार्टिन एंडर

2

हास्केल, ३०

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

यह सभी आकार की सूचियों और 20 से अधिक की सूचियों के लिए काम करता है। यह 15 बाइट्स लंबा हो सकता है यदि Data.List आयात किया गया है:

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

— गर्वित हेकलर
स्रोत

2

स्कीम - 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))))

बहुत प्रतिस्पर्धी नहीं है। लेकिन मुझे लेखन योजना पसंद है :),

यहाँ अन-कोडित कोड है:

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

— क्रंचर
स्रोत

1

पायथन, 37 वर्ण

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

— ग्रेग हेविल
स्रोत

मुझे कुछ सेकंड के लिए मारो। BTW, यह है range(21)।

— qwr

यह सबसे छोटा उपाय लगता है। पुनरावर्ती समाधान f=lambda l,i=0:i in l and f(l,i+1)or iएक चार लंबा है और पुनरावृत्त समाधान i=0;l=input()\nwhile i in l:i+=1\nprint iदो चार्ट लंबा है (इनपुट संग्रहीत नहीं करता है इसे बार-बार लिया जाता है)। 20बाउंड के बिना , मुझे लगता है कि ये दृष्टिकोण प्रबल होंगे।

— xnor

क्या यह एक अनाम कार्य नहीं हो सकता है? यदि यह हो सकता है, तो आप 2 बाइट्स बचा सकते हैं।

— मेगा मैन

1

सी # - 64 चार्ट

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

~~हमेशा~~ दुर्लभतम सर्वोत्तम गोल्फिंग भाषा नहीं है, लेकिन लिखना और समझना आसान है :)

— DLeh
स्रोत

1

स्काला, 18 बाइट्स

0 to 20 diff l min

l 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

— 2xsaiko
स्रोत

1

जावा , 91 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— लीक नन
स्रोत

1

जावा 7, 69 66 बाइट्स

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

-3 बाइट्स @LeakyNun को धन्यवाद

स्पष्टीकरण:

न केवल 0-20 का समर्थन करता है, बल्कि इसके बजाय 0-2147483647 (जो वास्तव में बाइट्स बचाता है)।

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

टेस्ट कोड:

इसे यहाँ आज़माएँ।

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

आउटपुट:

— केविन क्रूज़सेन
स्रोत

हेह, पुस्तकालयों ।

— लीक नन

1

3 बाइट्स

— लीकी नून

1

एपीएल (डायलॉग) , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मैं शायद यहाँ कुछ महत्वपूर्ण याद कर रहा हूँ। प्रगति में गोल्फ ...

— user41805
स्रोत

1

टीआई-बेसिक, 24 बाइट्स

: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

यदि Prompt Xएक एकल संख्या के बजाय एक सूची दी जाती है, तो यह स्वचालित रूप से एक सूची बनाएगी जिसका नाम दिया Xजा सकता है ʟX।

— स्कॉट मिलनर
स्रोत

20 बाइट्स का उपयोग करके Ans:Prompt X:0:While not(prod(ʟX-Ans:Ans+1:End:Ans

— JosiahRyanW

1

स्टैक्स , 6 बाइट्स

¢╔⌂♀╠▬

इसे चलाएं और डीबग करें

व्याख्या

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

— मल्टी
स्रोत

1

APL (Dyalog Classic) , 11 बाइट्स

f←⊃⊢~⍨0,⍳∘⍴

इसे ऑनलाइन आज़माएं!

— TwiNight
स्रोत

1

जेली , 7 बाइट्स

एक और दृष्टिकोण। किसी भी धमनी के साथ एक श्रृंखला में इस्तेमाल किया जा सकता है, और श्रृंखला विभाजक या कुछ भी ज़रूरत नहीं है।

‘Ṭ;0i0’

क्योंकि उत्तर 256 से कम होने की गारंटी है, यह भी काम करता है:

जेली , 5 बाइट्स

⁹ḶḟµḢ

इसे ऑनलाइन आज़माएं!

— user202729
स्रोत

1

पॉवर्सशैल, 28 बाइट्स

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

टेस्ट स्क्रिप्ट:

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

आउटपुट:

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

स्पष्टीकरण:

वृद्धि $iजबकि $argsसरणी में पूर्णांक मान होता है +$i।
अंतिम पूर्णांक मान को आउटपुट करें +$i।

— Mazzy
स्रोत

1

मठगोल्फ , 5 4 बाइट्स

Jr,╓

इसे ऑनलाइन आज़माएं!

यह समाधान केवल 0 से 20 की सीमा तक ही सीमित है, हालांकि प्रारंभिक सीमा को बढ़ाकर इसे आसानी से बढ़ाया जा सकता है।

स्पष्टीकरण:

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

वैकल्पिक रूप से, सभी संख्याओं के लिए 5 बाइट समाधान:

Åï╧▲ï

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

— मजाक कर रहा है
स्रोत

नए बदलावों के साथ (उम्मीद है) आज TIO में जोड़े जा रहे हैं, इस समस्या का 4 बाइट समाधान है। यह कोड में परिभाषित एक ऊपरी सीमा तक सीमित है, लेकिन चूंकि MathGolf में 10 ^ 8 के लिए 1-बाइट शाब्दिक है, इसलिए इसे ध्यान देने योग्य नहीं होना चाहिए।

— अधिकतम

यह सटीक समाधान मैं था (मैं इस्तेमाल किया था Zके बजाय Jक्योंकि मैं आलसी था)।

— मैक्स

0

पर्ल - 34

यहाँ एक सबरूटीन है।

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

इसके साथ टेस्ट करें:

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

— hmatt1
स्रोत

0

जावा, 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;
}

— Ypnypn
स्रोत

-1टेस्ट केस के लिए प्रोड्यूस करता है []।

— OldCurmudgeon

0

कोबरा - 50

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

— Οurous
स्रोत

0

जावास्क्रिप्ट, 74

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

अच्छा और सरल! लूप करते समय खाली नोट करें।

— सीन लाथम
स्रोत

0

जावास्क्रिप्ट (E6) 35

पुनरावर्ती कार्य, इनपुट में सरणी पैरामीटर और वापस लौटना mex। 20 तक सीमित नहीं

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

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

उत्पादन

[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

— edc65
स्रोत

0

PHP, 38 बाइट्स

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

PHP, 39 बाइट्स

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

— जार्ग हुल्सरमन
स्रोत

न्यूनतम बहिष्कृत संख्या

अजगर , 6 बाइट्स

उदाहरण चलाते हैं

यह काम किस प्रकार करता है

सीजेएम, 11 8 बाइट्स

जे - 13 चार

गोल्फक्राफ्ट 7

बर्लेस्क - 9 बाइट्स

बैश + कोरुटिल्स, 23 बाइट्स

रूबी, 32 बाइट्स

GolfScript ( 10 9 बाइट्स)

ज़ोजो, 55 बाइट्स

रूबी, २२

व्याख्या

हास्केल, ३०

स्कीम - 219

पायथन, 37 वर्ण

स्काला, 18 बाइट्स

जावा , 91 बाइट्स

जावा 7, 69 66 बाइट्स

एपीएल (डायलॉग) , 19 बाइट्स

टीआई-बेसिक, 24 बाइट्स

स्टैक्स , 6 बाइट्स

APL (Dyalog Classic) , 11 बाइट्स

जेली , 7 बाइट्स

जेली , 5 बाइट्स

पॉवर्सशैल, 28 बाइट्स

मठगोल्फ , 5 4 बाइट्स

स्पष्टीकरण:

स्पष्टीकरण:

पर्ल - 34

जावा, 93

कोबरा - 50

जावास्क्रिप्ट, 74

जावास्क्रिप्ट (E6) 35

PHP, 38 बाइट्स

PHP, 39 बाइट्स