Завдання полягає у виявленні відсутнього числа у рядку невизначених цілих чисел.

Вам надається рядок цифр (дійсне введення відповідатиме звичайному вираженню ^[1-9][0-9]+$). Рядок представляє послідовність цілих чисел. Наприклад, 1234567891011. Усі числа в послідовності знаходяться в діапазоні від 1і 2147483647включно.

Послідовність - це ряд чисел, де кожне число на одне більше, ніж його попередник. Однак ця послідовність може містити одне і лише одне відсутнє число з послідовності. Можливо, що дана рядок також не містить відсутніх чисел із послідовності. Рядок завжди буде містити щонайменше два числа з послідовності.

Код повинен виводити або повертати пропущене значення, або 0(це 0- не хибне значення) у випадку, якщо не знайдено відсутніх значень.

Нижче наведено дійсні входи та їх вихід / повернення:

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  

Хоча все це описується як "рядок" як вхід, якщо мова здатна обробляти довільно великі числа ( dcі mathematica, я дивлюся на вас двох), введення може бути довільно великим числом замість рядка, якщо це робить код простіше.

^{Для довідки, це надихнуло питання Programmers.SE: Знайдіть відсутні рядки в послідовності в рядку}

Haskell, 115 112 байт

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:" "])

Перший рядок - це визначення функції помічника, другий - основна анонімна функція. Перевірте тестові випадки (мені довелося запускати коротші тести через часові обмеження).

Пояснення

Це грубе рішення: розділити рядок на слова всіма можливими способами, проаналізувати слова на цілі числа, побачити, чи є діапазон з одним елементом (повертаючи цей елемент, 0інакше) та взяти максимум за всі розщеплення. Перевірка діапазону з відсутнім елементом виконується у функції помічника g, яка бере список bі повертає єдиний елемент у діапазоні, [head of b..last of b]якого немає b, або 0якщо такого не існує.

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 байт

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

Пояснення

Досить ефективний підхід. Завершується миттєво для всіх тестових випадків.

Отримує кожну підрядку з початку вхідного рядка як число nта ініціалізує пропущене число mдо 0. Потім він неодноразово видаляє nз початку рядка, кроки nта шукає рядок для нього. Якщо index of n != 0, перевіряє m. Якщо m == 0встановити m = nта продовжити, якщо ні, то є кілька пропущених номерів, тому перестаньте перевіряти цю підрядку. Цей процес триває, поки не буде видалено всю нитку.

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

Менше гольфу і пояснено

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
}

Тест

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 байт

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

Безумовно

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 */
}