[Question]
  [
**Background:**
I originally posted this question last night, and received backlash on its vagueness. I have since consulted many personnel concerning not only the wording of the problem, but also its complexity (which is not O(1)). This programming problem is an evil spin on an Amazon interview question.
**Question:**
Given a String of randomly concatenated integers [0, 250), 0 to 250 exclusive, there is ONE number missing in the sequence. Your job is to write a program that will calculate this missing number. There are no other missing numbers in the sequence besides the one, and that is what makes this problem so difficult, and possibly computationally hard.
Doing this problem by hand on smaller Strings, such as examples 1 and 2 below are obviously very easy. Conversely, computing a missing number on incredibly large datasets involving three-digit or four-digit numbers would be incredibly difficult. The idea behind this problem is to construct a program that will do this process FOR you.
**Important Information:** 
One thing that appeared as rather confusing when I posted this problem last night was: what exactly a missing number is defined as. A missing number is the number INSIDE of the range specified above; NOT necessarily the digit. In example 3, you will see that the missing number is 9, even though it appears in the sequence. There are 3 places the DIGIT 9 will appear in a series of [0, 30): “9”, “19”, and “29”. Your objective is to differentiate between these, and discover that 9 is the missing NUMBER (inside of example 3). In other words, the tricky part lies in finding out which sequences of digits are complete and which belong to other numbers.
**Input:**
The input is a String S, containing integers from 0 to 249 inclusive, or 0 to 250 exclusive (in other words, [0, 250)). These integers, as stated above, are scrambled up to create a random sequence. There are NO delimiters (“42, 31, 23, 44”), or padding 0’s (003076244029002); the problems are exactly as described in the examples. **It is guaranteed that there is only 1 solution in the actual problems. Multiple solutions are not permitted for these.**
**Winning Criteria:**
Whoever has the fastest, and lowest memory usage will be the winner. In the miraculous event that a time ties, lower memory will be used for the time breaker. Please list Big O if you can!
**Examples:**
*Examples 1 and 2 have a range of [0, 10)*
*Examples 3 and 4 have a range of [0, 30)*
(Examples 1-4 are just for demonstration. Your program needn't to handle them.)
*Examples 5 has a range of [0, 250)*
```
1. 420137659    
- Missing number => 8
2. 843216075    
- Missing number => 9  
3. 2112282526022911192312416102017731561427221884513 
- Missing number => 9
4. 229272120623131992528240518810426223161211471711
- Missing number => 15
5. 11395591741893085201244471432361149120556162127165124233106210135320813701207315110246262072142253419410247129611737243218190203156364518617019864222241772384813041175126193134141008211877147192451101968789181153241861671712710899168232150138131195104411520078178584419739178522066640145139388863199146248518022492149187962968112157173132551631441367921221229161208324623423922615218321511111211121975723721911614865611197515810239015418422813742128176166949324015823124214033541416719143625021276351260183210916421672722015510117218224913320919223553222021036912321791591225112512304920418584216981883128105227213107223142169741601798025
- Missing number => 71
Test Data: 
Problem 1: 6966410819610521530291368349682309217598570592011872022482018312220241246911298913317419721920718217313718080857232177134232481551020010112519172652031631113791105122116319458153244261582135510090235116139611641267691141679612215222660112127421321901862041827745106522437208362062271684640438174315738135641171699510421015199128239881442242382361212317163149232839233823418915447142162771412092492141987521710917122354156131466216515061812273140130240170972181176179166531781851152178225242192445147229991613515911122223419187862169312013124150672371432051192510724356172282471951381601241518410318414211212870941111833193145123245188102
Problem 2: 14883423514241100511108716621733193121019716422221117630156992324819917158961372915140456921857371883175910701891021877194529067191198226669314940125152431532281961078111412624224113912011621641182322612016512820395482371382385363922471472312072131791925510478122073722091352412491272395020016194195116236186596116374117841971602259812110612913254255615723013185162206245183244806417777130181492211412431591541398312414414582421741482461036761192272120204114346205712198918190242184229286518011471231585109384415021021415522313136146178233133168222201785172212108182276835832151134861116216716910511560240392170208215112173234136317520219
Problem 3: 1342319526198176611201701741948297621621214122224383105148103846820718319098731271611601912137231471099223812820157162671720663139410066179891663131117186249133125172622813593129302325881203242806043154161082051916986441859042111711241041590221248711516546521992257224020174102234138991752117924457143653945184113781031116471120421331506424717816813220023315511422019520918114070163152106248236222396919620277541101222101232171732231122301511263822375920856142187182152451585137352921848164219492411071228936130762461191564196185114910118922611881888513917712153146227193235347537229322521516718014542248813617191531972142714505519240144
Problem 4: 2492402092341949619347401841041875198202182031161577311941257285491521667219229672211881621592451432318618560812361201172382071222352271769922013259915817462189101108056130187233141312197127179205981692121101632221732337196969131822110021512524417548627103506114978204123128181211814236346515430399015513513311152157420112189119277138882021676618323919018013646200114160165350631262167910238144334214230146151171192261653158161213431911401452461159313720613195248191505228186244583455139542924222112226148941682087115610915344641782142472102436810828123731134321131241772242411722251997612923295223701069721187182171471055710784170217851
```
  
[Answer]
# [Clingo](https://potassco.org/clingo/), ≈ 0.03 seconds
This is too fast to be accurately measured—you’ll need to allow larger input cases rather than artificially stopping at 250.
```
% cat(I) means digits I and I+1 are part of the same number.
{cat(I)} :- digit(I, D), digit(I+1, E).
% prefix(I, X) means some digits ending at I are part of the same
% number prefix X.
prefix(I, D) :- digit(I, D), not cat(I-1), D < n.
prefix(I, 10*X+D) :- prefix(I-1, X), digit(I, D), cat(I-1), X > 0, 10*X+D < n.
% Every digit is part of some prefix.
:- digit(I, D), {prefix(I, X)} = 0.
% If also not cat(I), then this counts as an appearance of the number
% X.
appears(I, X) :- prefix(I, X), not cat(I).
% No number appears more than once.
:- X=0..n-1, {appears(I, X)} > 1.
% missing(X) means X does not appear.
missing(X) :- X=0..n-1, {appears(I, X)} = 0.
% Exactly one number is missing.
:- {missing(X)} != 1.
#show missing/1.
```
### Example input
Input is a list of (*k*, *k*th digit) pairs. Here is problem 1:
```
#const n = 250.
digit(0,6;1,9;2,6;3,6;4,4;5,1;6,0;7,8;8,1;9,9;10,6;11,1;12,0;13,5;14,2;15,1;16,5;17,3;18,0;19,2;20,9;21,1;22,3;23,6;24,8;25,3;26,4;27,9;28,6;29,8;30,2;31,3;32,0;33,9;34,2;35,1;36,7;37,5;38,9;39,8;40,5;41,7;42,0;43,5;44,9;45,2;46,0;47,1;48,1;49,8;50,7;51,2;52,0;53,2;54,2;55,4;56,8;57,2;58,0;59,1;60,8;61,3;62,1;63,2;64,2;65,2;66,0;67,2;68,4;69,1;70,2;71,4;72,6;73,9;74,1;75,1;76,2;77,9;78,8;79,9;80,1;81,3;82,3;83,1;84,7;85,4;86,1;87,9;88,7;89,2;90,1;91,9;92,2;93,0;94,7;95,1;96,8;97,2;98,1;99,7;100,3;101,1;102,3;103,7;104,1;105,8;106,0;107,8;108,0;109,8;110,5;111,7;112,2;113,3;114,2;115,1;116,7;117,7;118,1;119,3;120,4;121,2;122,3;123,2;124,4;125,8;126,1;127,5;128,5;129,1;130,0;131,2;132,0;133,0;134,1;135,0;136,1;137,1;138,2;139,5;140,1;141,9;142,1;143,7;144,2;145,6;146,5;147,2;148,0;149,3;150,1;151,6;152,3;153,1;154,1;155,1;156,3;157,7;158,9;159,1;160,1;161,0;162,5;163,1;164,2;165,2;166,1;167,1;168,6;169,3;170,1;171,9;172,4;173,5;174,8;175,1;176,5;177,3;178,2;179,4;180,4;181,2;182,6;183,1;184,5;185,8;186,2;187,1;188,3;189,5;190,5;191,1;192,0;193,0;194,9;195,0;196,2;197,3;198,5;199,1;200,1;201,6;202,1;203,3;204,9;205,6;206,1;207,1;208,6;209,4;210,1;211,2;212,6;213,7;214,6;215,9;216,1;217,1;218,4;219,1;220,6;221,7;222,9;223,6;224,1;225,2;226,2;227,1;228,5;229,2;230,2;231,2;232,6;233,6;234,0;235,1;236,1;237,2;238,1;239,2;240,7;241,4;242,2;243,1;244,3;245,2;246,1;247,9;248,0;249,1;250,8;251,6;252,2;253,0;254,4;255,1;256,8;257,2;258,7;259,7;260,4;261,5;262,1;263,0;264,6;265,5;266,2;267,2;268,4;269,3;270,7;271,2;272,0;273,8;274,3;275,6;276,2;277,0;278,6;279,2;280,2;281,7;282,1;283,6;284,8;285,4;286,6;287,4;288,0;289,4;290,3;291,8;292,1;293,7;294,4;295,3;296,1;297,5;298,7;299,3;300,8;301,1;302,3;303,5;304,6;305,4;306,1;307,1;308,7;309,1;310,6;311,9;312,9;313,5;314,1;315,0;316,4;317,2;318,1;319,0;320,1;321,5;322,1;323,9;324,9;325,1;326,2;327,8;328,2;329,3;330,9;331,8;332,8;333,1;334,4;335,4;336,2;337,2;338,4;339,2;340,3;341,8;342,2;343,3;344,6;345,1;346,2;347,1;348,2;349,3;350,1;351,7;352,1;353,6;354,3;355,1;356,4;357,9;358,2;359,3;360,2;361,8;362,3;363,9;364,2;365,3;366,3;367,8;368,2;369,3;370,4;371,1;372,8;373,9;374,1;375,5;376,4;377,4;378,7;379,1;380,4;381,2;382,1;383,6;384,2;385,7;386,7;387,1;388,4;389,1;390,2;391,0;392,9;393,2;394,4;395,9;396,2;397,1;398,4;399,1;400,9;401,8;402,7;403,5;404,2;405,1;406,7;407,1;408,0;409,9;410,1;411,7;412,1;413,2;414,2;415,3;416,5;417,4;418,1;419,5;420,6;421,1;422,3;423,1;424,4;425,6;426,6;427,2;428,1;429,6;430,5;431,1;432,5;433,0;434,6;435,1;436,8;437,1;438,2;439,2;440,7;441,3;442,1;443,4;444,0;445,1;446,3;447,0;448,2;449,4;450,0;451,1;452,7;453,0;454,9;455,7;456,2;457,1;458,8;459,1;460,1;461,7;462,6;463,1;464,7;465,9;466,1;467,6;468,6;469,5;470,3;471,1;472,7;473,8;474,1;475,8;476,5;477,1;478,1;479,5;480,2;481,1;482,7;483,8;484,2;485,2;486,5;487,2;488,4;489,2;490,1;491,9;492,2;493,4;494,4;495,5;496,1;497,4;498,7;499,2;500,2;501,9;502,9;503,9;504,1;505,6;506,1;507,3;508,5;509,1;510,5;511,9;512,1;513,1;514,1;515,2;516,2;517,2;518,2;519,3;520,4;521,1;522,9;523,1;524,8;525,7;526,8;527,6;528,2;529,1;530,6;531,9;532,3;533,1;534,2;535,0;536,1;537,3;538,1;539,2;540,4;541,1;542,5;543,0;544,6;545,7;546,2;547,3;548,7;549,1;550,4;551,3;552,2;553,0;554,5;555,1;556,1;557,9;558,2;559,5;560,1;561,0;562,7;563,2;564,4;565,3;566,5;567,6;568,1;569,7;570,2;571,2;572,8;573,2;574,4;575,7;576,1;577,9;578,5;579,1;580,3;581,8;582,1;583,6;584,0;585,1;586,2;587,4;588,1;589,5;590,1;591,8;592,4;593,1;594,0;595,3;596,1;597,8;598,4;599,1;600,4;601,2;602,1;603,1;604,2;605,1;606,2;607,8;608,7;609,0;610,9;611,4;612,1;613,1;614,1;615,1;616,8;617,3;618,3;619,1;620,9;621,3;622,1;623,4;624,5;625,1;626,2;627,3;628,2;629,4;630,5;631,1;632,8;633,8;634,1;635,0;636,2).
```
### Example output
```
$ clingo missing.lp problem1.lp 
clingo version 5.2.2
Reading from missing.lp ...
Solving...
Answer: 1
missing(148)
SATISFIABLE
Models       : 1+
Calls        : 1
Time         : 0.032s (Solving: 0.00s 1st Model: 0.00s Unsat: 0.00s)
CPU Time     : 0.032s
```
[Answer]
# C++, 5000 random test cases in 6.1 seconds
This is practically fast, but there may exist some testcases that make it slow. Complexity unknown.
If there are multiple solutions, it will print them all. [Example](https://tio.run/##jVZNb@M2ED3bv4JBgcSqE4NDfceOgT3tZbt7Kwq4biArcsKsIxmy3C1q@K83fUNSipxkuw0cmBoNZ968eRw6326v7vP8@fknXeab/V0hZvlT1jzMhy@GlW52RdO37Jpal/d9y59F3lR135K/ddIVbEX21Ldlm/uq1s0DjMO8KneN0GUjfv3w6faXD7@JG6FCOe29@PTlo3uxqe5JjlrHK0GeGAuaDvc7ZBWrqtrs4LVr7q6vbQEz5zufDofGvM10Pdvpv4vb5lLY77nIq33ZjGxC42XLOMdDfSnesTdZfV803vAwHNgYIis5s7wU1XqNvHa9rTo4duf1dQnbdDhYV7UYTcWo88b7yVqXdyMbuo3jeeLsvQicbzxuM1jf8dhD5Lpo9nVptzxlX4tbrngEd@MMj@NwyESJu/Vu1IJvqRCrk3Jtg2e99HPHiaH6XOQlkHKLLBd6LUYrcWOqWWTLCQcdoYSMoa6Yk6l1ypxT5@FQN/W@QKcGHHLr/A1VbNDGgK9Zqwg8oGiBzCbqSVbOsPLECtr7iigDDrcVPwuSkIxzXazG46X4Q1zIC6bOBNkifCuw83NxhhIX2yUvt9yKxqYbOPONgzywm5lTkAkWrXKYnuZ1ef3d62yzM6bjkD/Oz1mPrNl6nzeiymtOyyxsLgUif8Qe08VqW9QZN8nJF57nQnuui4c280bMhZ5spuI4PIJgDpRnm9H3utxr8pseY/VZ9LsHKP04QDAXRuXv986R@6p3zIheGtyNLi1NvHG9ye6dEAY9hO4EtqerqW6tfaRNI5mvsvrGyw7Co4XwCAif8dUmH2T7phI5XtopwMp4XF62R7xr7cggGcMN57TeQQdzHj@dvmwV7TskR8RDPtkVqOgOUnAriM9GduRdisej67@JcGbSQG0NC1i/kQ77aCNEdrLs3DAQMD7Z7ncPt6ss/zpCfs/oD6S@iPRoT98Z@7Yn79ARW9Wm@smquNclI@OHAiMJy8XyvfGYvTscV97Bgc7aszgTq1YsR0Opc@DzgjkpT8@LQTrsoWK8HSp@MKheC@9EwJtd084ObjDOhLg2A7BTnBt@np7Uwgh@oScfl68nUndAT8T3tLUnwG3Zr7AeIVA3ReDRm0PkpNYKHW8X0g2e5dtUgzc@vTnDQingKE7TeFxxTwB2/ld/FuxjqBp0eOvC7ME8sFS/pgmOLzTp/6hD/7AK/eMa9A8r0J7D6VLw5IJvTy9HO9KeMpaIuZV73cLXd0fUiRkhYK6rVWvPdSnmcxfA3EkLklzIwYr2/c9x@j8GXzuZ8oesxky6fjvHcKQXj4678biNafy7Jm0X2nlcXcHj8FanJyOwB4Zkh2Pw7UFvCtx8mBVXVx7v6rVB9@7Hu8r1n6@Pl182lTYie5mCp1eoUzJmFscxBPfi52bfUTgQJmRZ/NXc4mJ72jdZo6vS6LwbAPxgB4D3MtNM1FOlWniY6o2YzUxahoHlxe/lxbTVq@Q78aRh18bXay8miO0APo/uPmQE3JyT4LoLCyk@P1MqQ0khUZikIfkpRWGiVBwnpPwgVDGRpDRSfhj7RGlCfqwoiH2fVJRESahkEAeUUAxzqhReUxISfIMwUJSoKFRBQIooDpQPX0KSlAJfIYAfhalPfqBkrKRvnGDEmmIJQBQRgiJGkJCU5PsqYJiE3ZEK/TSICAlDQKDQD4hghSWNUhWQjPBMiR8iRhKnJBOZIhb7kw@kQRolSBApBE6SJKAoDgnOSoYcNkhJJQkcIwVYSQpcKqEwIB/cSMQnGTATKDEKVEpxRKgySmKpUEDoJ2RqVgEwBBTGhPJQEoiWUaJQlkxTSSA3QmKSsKQJMCnA9kMkTWOFTiSRwp@P/zDyQxCkAMcP0A/QmKJogFGpj6VEmyiRSiZoGgF9wm2jSIK6kBGnAINOxBHeglBJEXxiipk9BEfuMGYaABgv0QewEPkR4KAZYYSUKADERnEcIGaquFPgPQXLUA78QQHMqBJ8wR3QuP@gQKFxyJ8yMC4AigBwrIFV/ZPzz4Ld89UX/18).
**Explanation:**
1. Count the occurrences of digits.
2. List all possible answers.
3. Check if a candidate is a valid answer:
3-1. Try to split the string(s) by numbers which only occur once and mark it as identified, except the candidate.  
For example, `2112282526022911192312416102017731561427221884513` has only one `14`, so it can be split into `211228252602291119231241610201773156` and `27221884513`.
3-2. If any split string has length 1, mark it as identified.  
If any contradiction is made (identified more than once), the candidate is not valid.  
If we cannot find the candidate in the string, the candidate is valid.
3-3. If any split is made, repeat step 3-1. Otherwise, do a brute force search to check if the candidate is valid.
```
#include <cmath>
#include <bitset>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
const int VAL_MAX = 250;
const int LOG_MAX = log10(VAL_MAX - 1) + 1;
using bools = std::bitset<VAL_MAX>;
std::pair<size_t, size_t> count(const std::string& str, const std::string& target)
{
    size_t ans = 0, offset = 0, pos = std::string::npos;
    for (; (offset = str.find(target, offset)) != std::string::npos; ans++, pos = offset++);
    return std::make_pair(ans, pos);
}
bool dfs(size_t a, size_t b, const std::vector<std::string>& str, bools& cnt, int t)
{ // input: string id, string position, strings, identified, candidate
    if (b == str[a].size()) a++, b = 0;
    if (a == str.size()) return true;   // if no contradiction on all strings, the candidate is valid
    int p = 0;
    for (int i = 0; i < LOG_MAX; i++) { // assume str[a][b...b+i] is a number
        if (str[a].size() == b) break;
        p = p * 10 + (str[a][b++] ^ '0');
        if (p < VAL_MAX && !cnt[p] && p != t) { //if no contradiction
            cnt[p] = true;
            if (dfs(a, b, str, cnt, t)) return true; // recursively check
            cnt[p] = false;
        }
    }
    return false;
}
struct ocr {
    int l, r, G;
    bool operator<(const ocr& i) const { return l > i.l; }
};
int cal(std::vector<std::string> str, bools cnt, int t)
{ // input: a list of strings, whether a number have identified, candidate
  // try to find numbers that only occur once in those strings
    int N = str.size();
    std::vector<ocr> pos;
    for (int i = 0; i < VAL_MAX; i++) {
        if (cnt[i]) continue;             // try every number which haven't identified
        int flag = 0;
        std::string target = std::to_string(i);
        ocr now;
        for (int j = 0; j < N; j++) {     // count occurences
            auto c = count(str[j], target);
            if ((flag += c.first) > 1) break;
            if (c.first) now = {c.second, c.second + target.size(), j};
        }
        if (!flag && t == i) return true; // if cannot find the candidate, then it is valid
        if (i != t && flag == 1) pos.push_back(now), cnt[i] = true;
        // if only occur once, then its position is fixed, mark as identified
    }
    if (!pos.size()) { // if no number is identified, do a brute force search
        std::sort(str.begin(), str.end(), [](const std::string& a, const std::string& b){return a.size() < b.size();});
        return dfs(0, 0, str, cnt, t);
    }
    std::sort(pos.begin(), pos.end());
    std::vector<std::string> lst;
    for (auto& i : pos) {      // split strings by identified numbers
        if ((size_t)i.r > str[i.G].size()) return false;
        std::string tmp = str[i.G].substr(i.r);
        if (tmp.size() == 1) { // if split string has length 1, it is identified
            if (cnt[tmp[0] ^ '0']) return false; // contradiction if it is identified before
            cnt[tmp[0] ^ '0'] = true;
        }
        else if (tmp.size()) lst.push_back(std::move(tmp));
        str[i.G].resize(i.l);
    }
    for (auto& i : str) { // push the remaining strings; same as above
        if (i.size() == 1) {
            if (cnt[i[0] ^ '0']) return false;
            cnt[i[0] ^ '0'] = true;
        }
        else if (i.size()) lst.push_back(std::move(i));
    }
    return cal(lst, cnt, t); // continue the split step with new set of strings
}
int main()
{
    std::string str;
    std::vector<ocr> pos;
    std::vector<int> prob;
    std::cin >> str;
    int p[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    for (int i = 0; i < VAL_MAX; i++)
        for (char j : std::to_string(i)) p[j ^ '0']++;
    for (char i : str) p[i ^ '0']--; // count digit occurrences
    {
        std::string tmp;
        for (int i = 0; i < 10; i++)
            while (p[i]--) tmp.push_back(i ^ '0');
        do {           // list all possible candidates (at most 4)
            int c = std::stoi(tmp);
            if (c < VAL_MAX && tmp[0] != '0') prob.push_back(c);
        } while (std::next_permutation(tmp.begin(), tmp.end()));
    }
    if (prob.size() == 1) { std::cout << prob[0] << '\n'; return 0; }
                       // if only one candidate, output it
    for (int i : prob) // ... or check if each candidate is valid
        if (cal({str}, bools(), i)) std::cout << i << '\n';
}
```
[Try it online!](https://tio.run/##jVbbbuM2EH22v4JBgcSqE4M33WLHwD7ty3b3rSjguoGsyAmzjmTIcreo4V9veoakFDnJdhsYMTUanjlzZjh0vt1e3ef58/NPpsw3@7uCzfKnrHmYD18MK9PsiqZv2TW1Ke/7lj@LvKnqviV/62Qq2IrsqW/LNvdVbZoHGId5Ve4aZsqG/frh0@0vH35jN0yGfNp78enLR/9iU90LPmodr5gI2JiJ6XC/Q1S2qqrNDl675u762iUw877z6XBozdvM1LOd@bu4bS6Z@56zvNqXzcgFtF4ujXM81JfsHXuT1fdFEwwPw4HDYFlJkfklq9ZrxHXrbdXRcTuvr0vYpsPBuqrZaMpGnTfeT9amvBs56BYnCNjZewgUbzxuIzjf8TgAcl00@7p0W56yr8UtZTyCu3WGx3E4JKHY3Xo3asm3UrDVSbquwLNe@LnXxEp9zvISTKlETguzZqMVu7HZLLLlhEBHSCEjqivSZOqcMu/UeXjWTb0vUKkBQW69v5WKDMYa8DVrOwIPSJohskU9iUoRVgFbofe@AmVAcFv2MxMcLeNdF6vxeMn@YBf8gqSzIFvAtw12fs7OkOJiu6TllkrRuHADb77xlAduM2kKMaGi6xySp3mdXn/3OtvsrOk4pI/389Yj9Wy9zxtW5TWFJRU2lwzIH7HHVrHaFnVGRfLtC89zZgJfxUMbecPmzEw2U3YcHiEwAeXZZvS9KveK/KbGWH1m/eqBSh8HDObMdvn7tfPivqodKWKWlndjSicTbVxvsnvfCIMeQ38C29PVVLfOPjK2kKRXWX2jZUfh0VF4BIXP@GqDD7J9U7EcL90UoM54XF62R7wr7cgyGcMN57TeoQ/mNH66/nJZtO8QHIiHfLIrkNEdWsGv0HwO2Yt3yR6Pvv4W4cyGQbc11MDmTeuQj7GNSE5OnRsiAsUn2/3u4XaV5V9HiB/Y/oOoL016dKfvjHzbk3fohK1qm/1kVdybkpjRQ4GRhOVi@d54zN4djqvg4Eln7VmcsVXbLEcrqXeg84I5yU/Pi2U67LEivh0rerCsXjfeSQNvdk07O6jAOBPs2g7AruP88AvMpGa24Rdm8nH5eiJ1B/Sk@Z627gT4LfsV1iMAdVMEHr05JHyrtY2OtwvuB8/ybajBG5/enKFGKeDITsMElHGvAdz8r/4syMdKNej41oXdg3ngpH4tExxfZDL/kYf5YRbmxzmYH2ZgAs/Th6DJBd9evxzdSHvKqEXsrdyrFr6@O6JOzICAua5WrT03JZvPPYC9kxaCUyIH17Tvf47T/zH42smUP2Q1ZtL12zmGI7149NqNxy2m9e@KtF0Y73F1BY/D2z49GYE9MoJ3PAbfHsymwM2HWXF1FdCuXhlM7368q3z96fp4@WVTGdtkL1Pw9Ar1nYyZRThW4B5@bvcdmSdhIcvir@YWF9vTvskaU5W2z7sBQA9uAAQvM82innaqo4ep3rDZzIYlGlhe/F5eTNt@5XQnnhTs2voG7cWEZjtAz6O/D4kBFecE3HSwaMXnZ6G0VCINZSTSRMRRJITkIsZHi1QnMo0jKfCRQguJP60SJXgodCK4SnSUSB4LmFKeJrESMhZAiLhIsUPFgNax4GkqpUqEhLMI4SGjWMSSR5ESKtWCYyXiNEmFtQghABlJnQoFxBCukZSJUGGKx1RxqWSYAI4rqWXCI66VCDUCcwQIETpKk0hrkYQp19LCCYkwWsAgkYtOYAlFFOoolILYhTFS49KmDRelhUrSVMR4DWZSa9DWKgpBNxSJFsiNBAB2pAmd4oBsyCMtYcDLCISl5CALcyiExgPpzFOR4IlDYiQLfI5ME6mQolRplIo0klzGMRISnCSn/0oihxh4iIh/UBHfkUqwjsNU8iSMEEAgrUQCExzDJARHFcoUZhQLvFBPZALUGBhJqiKhOKqrUbBUhBHqHUEycEsRUiRQBW@gc5IQFsTAPhGioqAai1RJFSodh6gyigIJJUkKBlzoENlqbEWMmMDRHzE6CNt0yKEGeMBL/5PTr4Ld89UX9S8 "C++ (gcc) – Try It Online")
[Answer]
# [Clean](http://clean.cs.ru.nl/Clean), ~0.3s
Fixed a huge bug in the algorithm, need to re-optimize it now.
```
module main
import StdEnv
import StdLib
import System.CommandLine
maxNum = 250
sample = "11395591741893085201244471432361149120556162127165124233106210135320813701207315110246262072142253419410247129611737243218190203156364518617019864222241772384813041175126193134141008211877147192451101968789181153241861671712710899168232150138131195104411520078178584419739178522066640145139388863199146248518022492149187962968112157173132551631441367921221229161208324623423922615218321511111211121975723721911614865611197515810239015418422813742128176166949324015823124214033541416719143625021276351260183210916421672722015510117218224913320919223553222021036912321791591225112512304920418584216981883128105227213107223142169741601798025"
case1 = "6966410819610521530291368349682309217598570592011872022482018312220241246911298913317419721920718217313718080857232177134232481551020010112519172652031631113791105122116319458153244261582135510090235116139611641267691141679612215222660112127421321901862041827745106522437208362062271684640438174315738135641171699510421015199128239881442242382361212317163149232839233823418915447142162771412092492141987521710917122354156131466216515061812273140130240170972181176179166531781851152178225242192445147229991613515911122223419187862169312013124150672371432051192510724356172282471951381601241518410318414211212870941111833193145123245188102"
case2 = "14883423514241100511108716621733193121019716422221117630156992324819917158961372915140456921857371883175910701891021877194529067191198226669314940125152431532281961078111412624224113912011621641182322612016512820395482371382385363922471472312072131791925510478122073722091352412491272395020016194195116236186596116374117841971602259812110612913254255615723013185162206245183244806417777130181492211412431591541398312414414582421741482461036761192272120204114346205712198918190242184229286518011471231585109384415021021415522313136146178233133168222201785172212108182276835832151134861116216716910511560240392170208215112173234136317520219"
case3 = "1342319526198176611201701741948297621621214122224383105148103846820718319098731271611601912137231471099223812820157162671720663139410066179891663131117186249133125172622813593129302325881203242806043154161082051916986441859042111711241041590221248711516546521992257224020174102234138991752117924457143653945184113781031116471120421331506424717816813220023315511422019520918114070163152106248236222396919620277541101222101232171732231122301511263822375920856142187182152451585137352921848164219492411071228936130762461191564196185114910118922611881888513917712153146227193235347537229322521516718014542248813617191531972142714505519240144"
case4 = "2492402092341949619347401841041875198202182031161577311941257285491521667219229672211881621592451432318618560812361201172382071222352271769922013259915817462189101108056130187233141312197127179205981692121101632221732337196969131822110021512524417548627103506114978204123128181211814236346515430399015513513311152157420112189119277138882021676618323919018013646200114160165350631262167910238144334214230146151171192261653158161213431911401452461159313720613195248191505228186244583455139542924222112226148941682087115610915344641782142472102436810828123731134321131241772242411722251997612923295223701069721187182171471055710784170217851"
failing = "0102030405060708090100101102103104105106107108109110120130140150160170180190200201202203204205206207208209210220230240249248247246245244243242241239238237236235234233232229228227226225224223222221219218217216215214213212211199198197196195194193192191189188187186185184183182181179178177176175174173172171169168167166165164163162161159158157156155154153152151149148147146145144143142141139138137136135134133132131129128127126125124123122121119118117116115114113112111999897969594939291898887868584838281797877767574737271696867666564636261595857565554535251494847464544434241393837363534333231292827262524232221191817161514131211987654321"
dupes = "19050151158951391658227781234527110196235731198137214733126868520474181772192213718517314542182652441211742304719519143231236593134207203121171237201705111617211824810013324511511436253946122155201534113626129692410611318356178791080921122151321949681166200188841675156120546124912883216212189712281541382202411041372421642917614416870223753814121124318415710310515010682172099012716167102179894920613516297239186222232225635312262134019719915382229399107111802082341491811011604815220291125247641482401691871755205639495788414314011714616366130175601931092467744819271230159131158714761192105218019822421812423322919341426216523821428232"
:: Position :== [Int]
:: Positions :== [Position]
:: Digit :== (Char, Int)
:: Digits :== [Digit]
:: Number :== ([Char], Positions)
:: Numbers :== [Number]
:: Complete :== (Numbers, [Digits])
numbers :: [[Char]]
numbers = [fromString (toString n) \\ n <- [0..(maxNum-1)]]
candidates :: [Char] -> [[Char]]
candidates chars
    = moreCandidates chars []
where
    moreCandidates :: [Char] [[Char]] -> [[Char]]
    moreCandidates [] nums
        = removeDup (filter (\num = isMember num numbers) nums)
    moreCandidates chars []
        = flatten [moreCandidates (removeAt i chars) [[c]] \\ c <- chars & i <- [0..]]
    moreCandidates chars nums
        = flatten [flatten [moreCandidates (removeAt i chars) [ [c : num] \\ num <- nums ]] \\  c <- chars & i <- [0..]]
        
singletonSieve :: Complete -> Complete
singletonSieve (list, sequence)
    | (list_, sequence_) == (list, sequence)
        = reverseSieve (list, sequence)
    = (list_, sequence_)
where
    singles :: Numbers
    singles 
        = filter (\(_, i) = length i == 1) list
    list_ :: Numbers
    list_
        = [(a, filter (\n = not (isAnyMember n (flatten [flatten b_ \\ (a_, b_) <- singles | a_ <> a]))) b) \\ (a, b) <- list]
    sequence_ :: [Digits]
    sequence_
        = foldr splitSequence sequence (flatten (snd (unzip singles)))
reverseSieve :: Complete -> Complete
reverseSieve (list, sequence)
    # sequence
        = foldr splitSequence sequence (flatten (snd (unzip singles)))
    # list
        = [(a, filter (\n = not (isAnyMember n (flatten [flatten b_ \\ (a_, b_) <- singles | a_ <> a]))) b) \\ (a, b) <- list]
    # list
        = [(a, filter (\n = or [any (isPrefixOf n) (tails subSeq) \\ subSeq <- map (snd o unzip) sequence]) b) \\ (a, b) <- list]
    = (list, sequence)
where
    singles :: Numbers
    singles
        = [(a, i) \\ (a, b) <- list, i <- [[subSeq \\ subSeq <- map (snd o unzip) sequence | isMember subSeq b]] | length i == 1]
    
splitSequence :: Position [Digits] -> [Digits]
splitSequence split sequence
    = flatten [if(isEmpty b) [a] [a, drop (length split) b] \\ (a, b) <- [span (\(_, i) = not (isMember i split)) subSeq \\ subSeq <- sequence] | [] < max a b]
indexSubSeq :: [Char] Digits -> Positions
indexSubSeq _ []
    = []
indexSubSeq a b
    # remainder
        = indexSubSeq a (tl b)
    | startsWith a b
        = [[i \\ (_, i) <- take (length a) b] : remainder]
    = remainder
where
    startsWith :: [Char] Digits -> Bool
    startsWith _ []
        = False
    startsWith [] _
        = False
    startsWith [a] [(b,_):_]
        = a == b
    startsWith [a:a_] [(b,_):b_]
        | a == b
            = startsWith a_ b_
        = False
missingNumber :: String -> [[Char]]
missingNumber string
    # string
        = [(c, i) \\ c <-: string & i <- [0..]]
    # locations
        = [(number, indexSubSeq number string) \\ number <- numbers]
    # digits
        = [length (indexSubSeq [number] [(c, i) \\ c <- (flatten numbers) & i <- [0..]]) \\ number <-: "0123456789"]
    # missing
        = (flatten o flatten) [repeatn (y - length b) a \\ y <- digits & (a, b) <- locations]
    # (answers, _)
        = hd [e \\ e <- iterate singletonSieve (locations, [string]) | length (filter (\(a, b) = (length b == 0) && (isMember a (candidates missing))) (fst e)) > 0]
    # answers
        = filter (\(_, i) = length i == 0) answers
    = filter ((flip isMember)(candidates missing)) ((fst o unzip) answers)
            
Start world
    # (args, world)
        = getCommandLine world
    | length args < 2
        = abort "too few arguments\n"
    = flatlines [foldr (\num -> \str = if(isEmpty str) num (num ++ [',' : str]) ) [] (missingNumber arg) \\ arg <- tl args]
```
Compile with `clm -h 1024M -s 16M -nci -dynamics -fusion -t -b -IL Dynamics -IL Platform main`
This works by taking every number the string has to contain, and counting the number of places the required digit sequence is present in the string. It then repeatedly does these steps:
* If number has no possible positions, that's the answer
* Remove every number with one possible position (call these `singles`)
* Remove every position from all remaining numbers which overlaps with any positions from the previously removed numbers (the `singles`)
[Answer]
# Rust
Port of [@Colera Su's C++ answer](https://codegolf.stackexchange.com/a/150002/110802) in Rust.
\$ \color{red} {\text{But I made some mistakes, the result of the rust code is not correct.}} \$
\$ \color{red} {\text{variable `prob` seems to be consistent, the logic that produces `prob` seems to be consistent. 
}} \$
Any help would be appreciated.
[Try it online!](https://tio.run/##1VhLb@NGEr7rV7RzcMgZmeluviXbixwWu4ckE2AGwQJeQaDklk0vRTIkNc7sxL998lXzIT6kibO3FQRJ3V311buqqeJQVl@@HErFyup@sdhmSaK2VZyl5WLxz6h8/DHKl7Pj8T5fLN4V96qI04flbPbdd2wL0or98v0P6x@//9eCHcr4v4rdMOny5fH4h3f/qI93noNDoyFnUal3rpiwuGkl2YPghsne0nI5@xryCLY9s6HTrKyKw7Zi77YF@zxjeCUNwVyvisHqoVu9zGbxPk/Yz1FRxVHy91/ZLit6KLuUqV@Ny1IluznLqkcFoMv3WJns6pZtsixpCOlFVFbCbm5qSivRJy@dkD76SDDcO5Wc12drBOCsCu9yitt1G57bnjrvs70ytE4EoDlNc6TSSblfldcI6slpjLU6NivpiSG87JBWRgkYRGnOqqh4UFW90phGHYw6JmYbP1Wx/aGqmRFlxL@/nURltY7Te/Xb9Czb7UrV8OiD58c4UfpY@0SzmTgv72pSy1pZO@watWpmz7ha/NsbJpZHg2t8bNYKvG1MshKVGuaRbqBjzbRsHKO/DA0@79GZjcfud6URtUmqbdp0K3iNXPmL2l6/r3TM52ybkj@Jrinf64aYMhTn1aJ17jBr4x3bUL4S5l20qg3oWb85Orchj6hQW5YJvS41VR2KlKEe1ZHzpW93G6f8iE45uIY7GbespsCpT9Ql/rmvwFBVKLIZyd8UKvrPWDK9SFzO3jDBYYPR4kTlevOpUqVh3m1WR5lXbPMt/7Zb96K6GWUDdMrZdduy2OUlu3iDeFgqrYpPRm5aWYHglqqojF2UlIgBSHJ2ccOqkebE1VDmc@3AnthGlM4MxLXOAx15kI5jcDYOQ49MhdYaTuOmY0RnbUlHCXlwwQZpqOuVUvGvZWGXD1mJEAFxsUjVM1VSlxtxkxutlwcpQSag/IzL2LQO6XMR5eusMC5rW6xtkqVqkqWYJVWcTlO01aeuaKgTW1W2LrWFg9pudN4l0cOwSNqTNHvGgW6sNIz4nIYQPjF8OHs50pN5xpOOp0lW4tuKK1UYJlLosFdFVE3VJyFbwDetldrqZdO8hsHW@iFhtxaf5JI@u0U5T5NnVETTtCG3Wxzc/AT3yPStJbTx@B71Su2Np743hpJeZmN1UfCcCqiiX/HrW0@DEdd1B4AWbWw9ktDKD@WjASNGvuyVSjypz0GHo54AnLhcq31efRqEr80PBI3pNtpm6BGLNsusqNCZjN@p2n9nUe2weshu6oXZY2lMp/aAHMO7nrWXTUlSjxjMHlKPRLRiu7laVqMafIXOXYVSBQ9KM7YK5AgY7mLrYfW1eaGr9Ww17vNarobBR0Ej@2RhQiioj@NBnKicj1FyoJsjEfb6Pz/f/ye186ZrOhrsROM535JHpn61J2v0abIxBQjS44JsOJln2tiyqpMZVOYp53aRgYB0S50mxu1t2e/6bWwp9qPYvsrJ8f@9i@NXODg@MzRpUIKoG9TN/NxH8bEShtVVT9NB@enHsDhbLPCD@Cx05/t1EqMCLxvG1jv9ij1WKyD3YBsUzOQq9lFtL@74Evej1fIVg5dOn@h0MCGt7WNUlBM/5XdP/cD3474a3adeziTfCeT8Lj6PetWhjq6ddTM54ea@vYKPTG1vp5C5GhlHJaiTwKjVCTDlKLVNWpHWZ3Kjc36RbU413SzLR3Nj2zQtPBmWarGo71e3xjj47YAeXkuJsfGhlarfqh4bTUXy3iho0Ks2bGue68yNQ@sCb7SLUyREU/EDhS46Sq3AOlcF@CN6gp1kzNlr/DB8uyLbrw/VLjA67LE32okHhipJL4xvPi/@9vLNnKxry4DmNRl7sqEdGf@Nu8WjQo8pD0nFYjyG1VCaGb1tMo9PNlId7uEFFk1CV19vsq7m7S26SYo5iydV9eeanepLcEh@2KDhRXHFfkIgfj7G4fgvwCRCdavp//exbP9HuP5wOwEie@8@rGbPj6pQGvTDgv4@mM/@iojRw5/@d0EH6ZrJV14kJvkaU1c8Il31u0/9V0GsL7aoGSJDkwHJit3eNMtx/ce9XjMSqa@c@s76P@r69Ke6PpFicafs04pd3wz0Hkp@Oq@sllM@o3LwOKKZ@3dSjUjXrkJ9VGg/3QzRRYnh2WXXly/CdqQtQld6IgyE73lCSC58vB0ROoEMfU8KvKVwhMTLsQNbcFc4geB24HiB5L7AVsjDwLeF9AUQPC5CcNg@oB1f8DCU0g6EBLFwQSE9X/iSe54t7NARHL@EHwah0DtCCEB60gmFDUQXpJ6UgbDdEMvQ5tKWbgA4bktHBtzjji1cB4I5BLgQ7YWB5zgicEPuSA0nJMQ4AhsStjgBdlzhuY7nSkHauT5M41KbDRLbEXYQhsLHMTSTjgO1Hdtzoa4rAkfANnIAsD2H0EkOlHW550hs4NCDwlJyKIttVwgHC/IzD0WAFYeLYSzwOSwNpA0TpR16oQg9yaXvwyDByeX0aUvY4AMPEvEBL@LbswP89t1Q8sD1IEDArEACEzq6gQsdbVeG2EawoBfiCUuA6gMjCG1P2BzRdRCwULge4u3BZdAthEgRwCs4gZ@DgLDgDPAJFxGFqr4IbWm7tuO7iDKCAhdKcik04MJxYa0DVsjwCRz54SODwOa4HN6AHqBy/gA)
```
use std::collections::HashMap;
use std::cmp::Ordering;
// const VAL_MAX: usize = 250;
// const LOG_MAX: f64 = (VAL_MAX as f64 - 1.0).log10() + 1.0;
const VAL_MAX: usize = 250;
const LOG_MAX: usize = 3;
struct Ocr {
    l: usize,
    r: usize,
    g: usize,
}
impl PartialEq for Ocr {
    fn eq(&self, other: &Self) -> bool {
        self.l == other.l
    }
}
impl Eq for Ocr {}
impl PartialOrd for Ocr {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
impl Ord for Ocr {
    fn cmp(&self, other: &Self) -> Ordering {
        other.l.cmp(&self.l)
    }
}
fn count(s: &str, target: &str) -> (usize, usize) {
    let mut count = 0;
    let mut last_index = 0;
    let mut offset = 0;
    while let Some(index) = s[offset..].find(target) {
        count += 1;
        offset += index + target.len();
        last_index = offset;
    }
    (count, last_index)
}
fn dfs(a: usize, mut b: usize, strs: &Vec<String>, cnt: &mut HashMap<usize, bool>, t: usize) -> bool {
    if b == strs[a].len() {
        b = 0;
        if a + 1 == strs.len() {
            return true;
        }
    }
    let mut p = 0;
    for _ in 0..LOG_MAX as usize {
        if strs[a].len() == b {
            break;
        }
        p = p * 10 + (strs[a].as_bytes()[b] as usize - b'0' as usize);
        b += 1;
        if p < VAL_MAX && !*cnt.entry(p).or_insert(false) && p != t {
            cnt.insert(p, true);
            if dfs(a, b, strs, cnt, t) {
                return true;
            }
            cnt.insert(p, false);
        }
    }
    false
}
fn cal(str: Vec<String>, mut cnt: HashMap<usize, bool>, t: usize) -> bool {
    let mut pos = Vec::new();
    for i in 0..VAL_MAX {
        if cnt.get(&i).unwrap_or(&false).clone() {
            continue;
        }
        let target = i.to_string();
        let mut flag = 0;
        let mut now = Ocr { l: 0, r: 0, g: 0 };
        for (j, str) in str.iter().enumerate() {
            let c = count(str, &target);
            flag += c.0;
            if flag > 1 {
                break;
            }
            if c.0 > 0 {
                now = Ocr { l: c.1, r: c.1 + target.len(), g: j };
            }
        }
        if flag == 0 && t == i {
            return true;
        }
        if i != t && flag == 1 {
            pos.push(now);
            cnt.insert(i, true);
        }
    }
    if pos.is_empty() {
        let mut str = str.clone();
        str.sort_by(|a, b| a.len().cmp(&b.len()));
        return dfs(0, 0, &str, &mut cnt, t);
    }
    pos.sort();
    let mut lst = Vec::new();
    let mut str = str.clone();
    for i in pos {
        if i.r > str[i.g].len() {
            return false;
        }
        let tmp = str[i.g][i.r..].to_string();
        if tmp.len() == 1 {
            let value = tmp.as_bytes()[0] as usize - b'0' as usize;
            if *cnt.get(&value).unwrap_or(&false) {
                return false;
            }
            cnt.insert(value, true);
        } else if !tmp.is_empty() {
            lst.push(tmp);
        }
        str[i.g].truncate(i.l);
    }
    for i in str {
        if i.len() == 1 {
            let value = i.as_bytes()[0] as usize - b'0' as usize;
            if *cnt.get(&value).unwrap_or(&false) {
                return false;
            }
            cnt.insert(value, true);
        } else if !i.is_empty() {
            lst.push(i);
        }
    }
    cal(lst, cnt, t)
}
fn main() {
    let mut str = String::new();
    std::io::stdin().read_line(&mut str).unwrap();
    let str = str.trim().to_string();
    let mut p = vec![0; 10];
    for i in 0..VAL_MAX {
        for j in i.to_string().chars() {
            p[j as usize - '0' as usize] += 1;
        }
    }
    for i in str.chars() {
        p[i as usize - '0' as usize] -= 1;
    }
    let mut tmp = String::new();
    for i in 0..10 {
        for _ in 0..p[i] {
            tmp.push((i as u8 + b'0') as char);
        }
    }
    let mut prob = Vec::new();
    loop {
        let c = tmp.parse::<usize>().unwrap();
        if c < VAL_MAX && tmp.chars().next().unwrap() != '0' {
            prob.push(c);
        }
        let mut tmp_bytes = tmp.into_bytes();
        if !tmp_bytes.next_permutation() {
            break;
        }
        tmp = String::from_utf8(tmp_bytes).unwrap();
    }
    println!("{:?}",prob);
    if prob.len() == 1 {
        println!("\n the result is: {:?}", prob[0]);
        return;
    }
    for i in prob {
        if cal(vec![str.clone()], HashMap::new(), i) {
            println!("\n the result is: {:?}", i);
        }
    }
}
pub trait NextPermutation {
    fn next_permutation(&mut self) -> bool;
}
impl<T> NextPermutation for [T]
where
    T: Ord,
{
    fn next_permutation(&mut self) -> bool {
        if self.len() < 2 {
            return false;
        }
        let mut i = self.len() - 1;
        while i > 0 && self[i - 1] >= self[i] {
            i -= 1;
        }
        if i == 0 {
            return false;
        }
        let mut j = self.len() - 1;
        while j >= i && self[j] <= self[i - 1] {
            j -= 1;
        }
        self.swap(j, i - 1);
        self[i..].reverse();
        true
    }
}
```
]