Thách thức là xác định số còn thiếu trong một chuỗi các số nguyên không giới hạn.

Bạn được cung cấp một chuỗi các chữ số (đầu vào hợp lệ sẽ khớp với biểu thức chính quy ^[1-9][0-9]+$). Chuỗi đại diện cho một chuỗi các số nguyên. Ví dụ , 1234567891011. Tất cả các số trong chuỗi nằm trong phạm vi từ 1và 2147483647bao gồm.

Chuỗi là một chuỗi các số trong đó mỗi số là một số lớn hơn số trước. Tuy nhiên, chuỗi này có thể chứa một và chỉ một số bị thiếu trong chuỗi. Có thể là một chuỗi đã cho cũng không chứa các số bị thiếu trong chuỗi. Chuỗi sẽ luôn chứa ít nhất hai số trong chuỗi.

Mã phải xuất hoặc trả về giá trị bị thiếu hoặc 0(đây 0không phải là giá trị giả) trong trường hợp không tìm thấy giá trị thiếu.

Sau đây là các đầu vào hợp lệ và đầu ra / trả về của chúng:

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  

Mặc dù tất cả những điều này được mô tả dưới dạng 'chuỗi' là đầu vào, nếu ngôn ngữ có khả năng xử lý số lượng lớn tùy ý ( dcvà mathematica, tôi đang nhìn vào hai bạn), đầu vào có thể là một số lớn tùy ý thay vì chuỗi nếu điều đó tạo ra mã dễ dàng hơn.

^{Để tham khảo, điều này được lấy cảm hứng từ câu hỏi của Lập trình viên. Câu hỏi: Tìm số bị thiếu trong chuỗi trong chuỗi}

Haskell, 115 112 byte

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

Dòng đầu tiên là một định nghĩa hàm trợ giúp, dòng thứ hai là hàm ẩn danh chính. Xác minh các trường hợp thử nghiệm (tôi đã phải chạy các thử nghiệm ngắn hơn vì giới hạn thời gian).

Giải trình

Đây là một giải pháp mạnh mẽ: chia chuỗi thành các từ theo tất cả các cách có thể, phân tích các từ thành số nguyên, xem liệu đó có phải là một phạm vi thiếu một phần tử không (trả lại phần tử đó, và 0nếu không), và lấy tối đa trên tất cả các mối nối. Kiểm tra phạm vi thiếu phần tử được thực hiện trong chức năng của trình trợ giúp g, trong đó có một danh sách bvà trả về phần tử duy nhất trong phạm vi [head of b..last of b]không có bhoặc 0nếu không tồn tại.

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 byte

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

Giải trình

Cách tiếp cận khá hiệu quả. Kết thúc ngay lập tức cho tất cả các trường hợp thử nghiệm.

Nhận từng chuỗi con từ đầu chuỗi đầu vào dưới dạng số nvà khởi tạo số còn thiếu mthành 0. Sau đó, nó liên tục loại bỏ ntừ đầu chuỗi, tăng nvà tìm kiếm chuỗi cho nó. Nếu index of n != 0, nó kiểm tra m. Nếu m == 0, đặt m = nvà tiếp tục, nếu không, có nhiều số bị thiếu nên dừng kiểm tra từ chuỗi con này. Quá trình này tiếp tục cho đến khi toàn bộ chuỗi đã được gỡ bỏ.

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

Ít chơi gôn và giải thích

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
}

Kiểm tra

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 byte

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

Bị đánh cắp

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