Buradaki zorluk, eksik sayıyı bir dizi bitmemiş tam sayı dizesinde belirlemektir.

Size bir basamak dizesi verilir (geçerli giriş normal ifadeyle eşleşir ^[1-9][0-9]+$). Dize, bir tamsayı dizisini temsil eder. Örneğin 1234567891011,. Sekanstaki tüm sayılar arasında 1ve 2147483647kapsayıcıdır.

Dizi, her sayının öncekinden bir büyük olduğu bir sayı dizisidir. Ancak bu sekans , sekanstan bir ve sadece bir eksik sayı içerebilir. Belirli bir dizenin diziden eksik numara içermemesi de mümkündür. Dize her zaman diziden en az iki sayı içerir.

Eksik değer bulunamaması durumunda kodun eksik değeri vermesi veya döndürmesi gerekir 0( veya bu bir 0- yanlış değer değildir).

Aşağıdakiler geçerli girdiler ve bunların çıktıları / dönüşleri:

input                         output    actual sequence (for refrence)
123467                        5         1 2 3 4 _ 6 7
911                           10        9 __ 11
123125126                     124       123 ___ 125 126
8632456863245786324598632460  8632458   8632456 8632457 _______ 8632459 8632460  
123                           0         1 2 3
8632456863245786324588632459  0         8632456 8632457 8632458 8632459  

Tüm bunlar giriş olarak 'dize' olarak tanımlansa da, dil keyfi olarak büyük sayıları işleyebiliyorsa ( dcve mathematicaikinize bakıyorum), giriş yaparsa bir dize yerine rastgele büyük bir sayı olabilir kolay kod.

^{Başvuru için bu, Programcılar'dan ilham almıştır.SE sorusu: Dizede eksik sayıyı sırayla bulun}

Haskell, 115112 bayt

g b|a<-[b!!0..last b]=last$0:[c|c<-a,b==filter(/=c)a]
maximum.map(g.map read.words.concat).mapM(\c->[[c],c:" "])

İlk satır yardımcı işlev tanımı, ikincisi ana anonim işlevdir. Test durumlarını doğrulayın (Zaman kısıtlamaları nedeniyle daha kısa testler yürütmek zorunda kaldım).

açıklama

Bu kaba bir güç çözümüdür: dizeyi olası tüm yollarla kelimelere ayırın, kelimeleri tamsayılara ayrıştırın, bir öğe eksik olan bir aralık olup olmadığını görün (bu öğeyi döndürme ve 0diğer türlü) ve tüm bölmelerde maksimum değeri alın. Menzil-ile-eksik-eleman onay yardımcı işlevinde yapılır glistesini alır bve aralıkta tek elemanını döndürür [head of b..last of b]içinde değil bya 0biri yaparsa yok.

g b|                         -- Define g b
    a<-[b!!0..last b]=       -- (with a as the range [head of b..last of b]) as:
    last$0:[...]             --  the last element of this list, or 0 if it's empty:
            c|c<-a,          --   those elements c of a for which
            b==filter(/=c)a  --   removing c from a results in b.
mapM(\c->[[c],c:" "])        -- Main function: Replace each char c in input with "c" or "c "
map(...)                     -- For each resulting list of strings:
  g.map read.words.concat    --  concatenate, split at spaces, parse to list of ints, apply g
maximum                      -- Maximum of results (the missing element, if exists)

JavaScript (ES6), 117 bayt

s=>eval(`for(i=l=0;s[i];)for(n=s.slice(x=i=m=0,++l);s[i]&&!x|!m;x=s.slice(x?i:i+=(n+"").length).search(++n))m=x?n:m`)

açıklama

Oldukça verimli bir yaklaşım. Tüm test senaryoları için anında bitirir.

Sayı olarak girdi dizinin başlangıcından itibaren her alt dize alır nve eksik numara başlatır miçin 0. Daha sonra ndizenin başlangıcından art arda kaldırılır , dizeyi artırır nve dizeyi arar. Eğer index of n != 0kontrol eder m. Varsa m == 0, ayarlayın m = nve devam edin, eğer değilse, birden fazla eksik numara vardır, bu nedenle bu alt dizeden kontrol etmeyi bırakın. Bu işlem, tüm dize kaldırılana kadar devam eder.

var solution =

s=>
  eval(`                     // use eval to use for loops without writing {} or return
    for(
      i=                     // i = index of next substring the check
      l=0;                   // l = length of initial substring n
      s[i];                  // if it completed successfully i would equal s.length
    )
      for(
        n=s.slice(           // n = current number to search for, initialise to subtring l
          x=                 // x = index of n relative to the end of the previous n
          i=                 // set i to the beginning of the string
          m=0,               // m = missing number, initialise to 0
          ++l                // increment initial substring length
        );
        s[i]&&               // stop if we have successfully reached the end of the string
        !x|!m;               // stop if there are multiple missing numbers
        x=                   // get index of ++n
          s.slice(           // search a substring that starts from the end of the previous
                             //     number so that we avoid matching numbers before here
            x?i:             // if the previous n was missing, don't increment i
            i+=(n+"").length // move i to the end of the previous number
          )
          .search(++n)       // increment n and search the substring for it's index
      )
        m=x?n:m              // if the previous number was missing, set m to it
  `)                         // implicit: return m

<input type="text" id="input" value="8632456863245786324598632460" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

JavaScript (ES6) 114

s=>eval("for(d=0,n=-9,z=s;z=z.slice((n+'').length);z.search(++n)?z.search(++n)?n=(z=s).slice(x=0,++d):x=n-1:0);x")  

Daha az golf ve açıklama

f=s=>{
  d = 0  // initial digit number, will be increased to 1 at first loop 
  n = -9 // initial value, can not be found
  z = s  // initializa z to the whole input string
  // at each iteration, remove the first chars of z that are 'n' 
  // 'd' instead of 'length' would be shorter, but the length can change passing from 9 to 10 
  for(; z=z.slice((n+'').length); ) 
  {
    ++n; // n is the next number expected in sequence
    if (z.search(n) != 0)
    {
      // number not found at position 0
      // this could be the hole
      // try to find the next number
      ++n;
      if (z.search(n) != 0)
      {
        // nope, this is not the correct sequence, start again
        z = s; // start to look at the whole string again
        x = 0; // maybe I had a candidate result in xm but now must forget it
        ++d;   // try a sequence starting with a number with 1 more digit
        n = z.slice(0,d) // first number of sequence
      }
      else
      {
        // I found a hole, store a result in x but check the rest of the string
        x = n-1
      }
    }
  }      
  return x // if no hole found x is 0
}

Ölçek

F=s=>eval("for(d=0,n=-9,z=s;z=z.slice((n+'').length);z.search(++n)?z.search(++n)?n=(z=s).slice(x=0,++d):x=n-1:0);x")

console.log=x=>O.textContent+=x+'\n'

elab=x=>console.log(x+' -> '+F(x))

function test(){ elab(I.value) }

;['123467','911','123125126','8632456863245786324598632460',
  '123','124125127','8632456863245786324588632459']
.forEach(t=>elab(t))

<input id=I><button  onclick='test()'>Try your sequence</button>
<pre id=O></pre>

Cı, 183 168 166 163 bayt

n,l,c,d,b[9];main(s,v,p)char**v,*p;{for(;s>1;)for(d=s=0,n=atoi(strncpy(b,p=v[1],++l)),p+=l;*p&&s<2;)p+=memcmp(p,b,c=sprintf(b,"%d",++n))?d=n,s++:c;printf("%d",d);}

Ungolfed

n,l,c,d,b[9];

main(s,v,p)char**v,*p;
{
    /* Start at length 1, counting upwards, while we haven't
       found a proper number of missing numbers (0 or 1) */
    for(;s>1;)
        /* Start at the beginning of the string, convert the
           first l chars to an integer... */
        for(d=s=0,n=atoi(strncpy(b,p=v[1],++l)),p+=l;*p&&s<2;)
            /* If the next number is missing, then skip, otherwise
               move forward in the string.... */
            p+=memcmp(p,b,c=sprintf(b,"%d",++n))?d=n,s++:c;

    printf("%d",d); /* print the missing number */
}