[Question]
  [
To interpret a positive integer very literally, write it in English words (without "and"), replace hyphens with spaces, replace each resulting word with its number value, and concatenate the results into a single number.
To write a positive integer more than 99 but less than 1000 in English words, prefix its last two digits written in English with **`[first digit in English]`**`hundred`  with a trailing space.
To write a positive integer more than 999 but less than 1 million in English words, use the following syntax: **`[part before the last 3 digits in English]`**`thousand`**`[last 3 digits in English]`**, all separated by spaces.
The task is to input a positive integer (less than 1 million) and output it, interpreted very literally.
# Examples
```
1 -> 1                       (one)
10 -> 10                     (ten)
16 -> 16                     (sixteen)
23 -> 203                    (twenty three)
111 -> 110011                (one hundred eleven)
123 -> 1100203               (one hundred twenty three)
1234 -> 110002100304         (one thousand two hundred thirty four)
12345 -> 1210003100405       (twelve thousand three hundred forty five)
123456 -> 110020310004100506 (one hundred twenty three thousand four hundred fifty six)
1056 -> 11000506             (one thousand fifty six)
101101 -> 11001100011001     (one hundred one thousand one hundred one)
110110 -> 1100101000110010   (one hundred ten thousand one hundred ten)
```
Feel free to add more test cases if necessary.
This is tagged [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 76 bytes
```
f=lambda n,k=1000:n>19and(f(n/k,k/10)+`k-k%4*5`)*(n>=k)+f(n%k,k/10)or`n`[:n]
```
[Try it online!](https://tio.run/##TZDRCsIwDEWf9Sv6IrY6MWm7gYP6IyJsIsNRzWT64tfPtKubL7c39zQh7fPzvnWkh6Fx9/pxudaCMu8QAEo64qGmq2wk7X3m9whqW/mdX9lNXqmNpKPzast0lWjXV1SdSjoPTdfznJdoSZwkZmKNa5UJiRAsjL4Ivoheh1yPuTbRm9QQO/gYS8RUYhoYb4dg6tDGpgg0iwE75XkAIQTDYiGfSTGPCdyy5FCkHSb6l3E57wKjpJ0i/DGYID/hXC4Xz76lN38O/5uK4txr@AI "Python 2 – Try It Online")
Test suite from Chas Brown.
A fully recursive solution that splits on place values `k=1000`, `k=100`, and `k=10`. The separator for the place values is computed as `k-k%4*5`, which maps 
```
1000 -> 1000
100  -> 100
10   -> 0
```
By stopping when `n<=19`, we avoid one-word numbers in the teens being split up. 
[Answer]
# [Gaia](https://github.com/splcurran/Gaia), ~~44~~ 43 bytes
```
:(!>
ℍZ:₸Z¤1>∧'0×¤ṙ$×:dẏ×,↑ℍṙ×
@3eZ,↑¦↓3eṙ×
```
Longer than my original answer, but it works now.
~~fixed my code again but now it's twice as sad~~
[Try it online!](https://tio.run/##S0/MTPz/30pD0Y7rUUtvlNWjph1Rh5YY2j3qWK5ucHj6oSUPd85UOTzdKuXhrv7D03UetU0EKgOKHZ7O5WCcGgUSOLTsUdtk41Sw4P//hkbGBgYGAA "Gaia – Try It Online")
```
@3eZ,↑¦↓3eṙ×  Main function.
@3eZ          Input divmod 1000, pushes input div 1000 then input mod 1000
    ,         Pair those two value into a list
     ↑¦       Run the upper function on both
       ↓      Call the function below (loops to top function)
        3eṙ   The string "1000"
           ×  Join the list with "1000"
ℍZ:₸Z¤1>∧'0×¤ṙ$×:dẏ×,↑ℍṙ×  Helper function. Called with 1 argument.
ℍZ                          Divmod with 100
  :₸Z                       Copy the mod part and divmod with 10
                            Stack is: [100s digit, arg mod 100, 10s digit, 1s digit]
     ¤1>                    Bring 10s digit to the top and check if it's greater than 1
        ∧                   Logical AND with 1s digit. (results in 0 or 1)
         '0×                Multiply the character 0 by that result
            ¤               Bring 'arg mod 100' to the top
             ṙ$             Get its string representation and split it into characters
                            (simply doing digit list doesn't work in the case it's 0)
               ×            Join this with the multiplied '0' string
                :d          Copy and parse as a number
                  ẏ         Is it positive? (0 or 1)
                   ×        Multiply the string of the number by that result.
                    ,       Pair: gives the list [100s digit, string from above]
                     ↑      Call the function above
                      >     Remove the first ^ elements from the pair
                       ℍṙ×  Join the resulting list with the string "100"
:(!>  Helper function 2. In this program it is only called with a list.
:(    Copy and get the first element.
  !   Boolean negate (0 or 1)
   >  Remove that many characters from the start of the list
```
[Answer]
# [Python 3](https://docs.python.org/3/)+[inflect](https://pypi.org/project/inflect/), 193 bytes
```
import inflect,re
exec("for i in re.sub('(and)|\W',' ',%sinput())).split():\n for j in range(0,6**8):\n  if i in %sj):\n   print(j,end='')\n   break"%(('inflect.engine().number_to_words(',)*2))
```
[Try it online!](https://tio.run/##LY7dCoJAEIXve4pFkJ2RRawgIug5uhHEn9HWdHbZXamgdzfT7g7f4Tsc@w53w8d51qM1LgjN7UB1UI529KIaotY4oRcsHKV@qkBCyQ1@8ptUUkgVe812CoCIqbeDXtIlZ/Gz@tUquSPI1ClJzmsjdLvtxb7fgLBOc4BeETdXKXFllaPyEcUA8v8oJe40E2DK01iRK4IpnsY1HqTC5IA4z/ss@wI "Python 3 – Try It Online")
Very naive solution which uses Python's `inflect` library. Here is the unfurled code:
```
import inflect,re
for i in re.sub('(and)|\W+',' ',inflect.engine().number_to_words(input())).split():
 for j in range(0,6**8):
  if i in inflect.engine().number_to_words(j):
   print(j,end='')
   break
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~26~~ ~~23~~ 21 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
₄вεтвεSÐP@θ1Ký0Û]тý₄ý
```
Port of [*@Neil*'s Charcoal answer](https://codegolf.stackexchange.com/a/195172/52210), so make sure to upvote him as well.  
-5 bytes thanks to *@Grimy*.
[Try it online](https://tio.run/##yy9OTMpM/f//UVPLhU3ntl5sApHBhycEOJzbYeh9eK/B4dmxF5sO7wXKH977/7@hgQEA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/R00tFzad23qxCUQGH54Q4HBuh6H34b0Gh2fX1l5sOrwXqODw3v86/6MNdQwNdAzNdIyMgQwgyxAoAGIbGZuACVMIaQaUBROGQKRjCKaBMgaxAA).
**Explanation:**
```
₄в                # Convert the (implicit) input-integer to base-1000 as list
                  #  i.e. 119100 → [119,100]
                  #  i.e. 23 → [23]
  ε               # Map each value to:
   тв             #  Convert the value to base-100 as list
                  #   i.e. [119,100] → [[1,19],[1,0]]
                  #   i.e. [23] → [[23]]
     ε            #  Map each value `y` to:
      S           #   Convert the current value to a list of digits
                  #    i.e. [[1,19],[1,0]] → [[[1],[1,9]],[[1],[0]]]
                  #    i.e. [[23]] → [[[2,3]]]
       Ð          #   Triplicate this list
        P         #   Take the product of each inner list of digits
                  #    i.e. [[[1],[1,9]],[[1],[0]]] → [[[1],[9]],[[1],[0]]
                  #    i.e. [[[2,3]]] → [[6]]
         @        #   Check if it's larger than or equal to each digit
                  #    i.e. [[[1],[1,9]],[[1],[0]]] and [[[1],[9]],[[1],[0]]
                  #     → [[[1],[1,1]],[[1],[1]]]
                  #    i.e. [[[2,3]]] and [[6]] → [[[0,0]]]
          θ       #   Keep only the last check of each
                  #    i.e. [[[1],[1,1]],[[1],[1]]] → [[[1],[1]],[[1],[1]]]
                  #    i.e. [[[0]]]
           1K     #   Remove all 1s from each 'string'
                  #    i.e. [[[1],[1]],[[1],[1]]] → [[[""],[""]],[[""],[""]]]
                  #    i.e. [[["0"]]]
             ý    #   Join the list of digits by this string
                  #    i.e. [[[1],[1,9]],[[1],[0]]] and [["",""],["",""]]→ [[1,19],[1,0]]
                  #    i.e. [[[2,3]]] and [["0"]] → [[203]]
      0Û          #   Remove any trailing 0s
                  #    i.e. [[1,19],[1,0]] → [[1,19],[1,""]]
                  #    i.e. [[203]] → [[203]]
  ]               # Close both maps
   тý             # Join the inner lists by "100"
                  #  i.e. [[1,19],[1,""]] → [110019,1100]
                  #  i.e. [[203]] → [203]
     ₄ý           # And then those strings by "1000"
                  #  i.e. [110019,1100] → 11001910001100
                  #  i.e. [203] → 203
                  # (after which the result is output implicitly)
```
[Answer]
# [PHP](https://php.net/), ~~137~~ ~~136~~ 143 bytes
```
function f($n){return$n>99?$n>999?f(substr($n,0,-3)).(1e3).f(substr($n,-3)):$n[0].'100'.f($n[1].$n[2]):($n>20&&$n%10?(0^$n/10).'0'.$n[1]:+$n);}
```
[Try it online!](https://tio.run/##TZDRjoMgEEXf@QrS0AKpSwftNlF364dYN@kajPuCRvCp6be7g7RNCTn3cmcyEMZ@XL6qEdnNtvV/g6WdYFbeJuPnyTJ7zvNqZV51ws2/zk9YTyD5yKRUQptMqvdCiAtma2gU1wBchXG1bhQybWSBp3MKux2zWw2VgB9mDxqk4ti6NhZ7vL68L8wb5x39pjXhmicIWHkKTLPAY0x0LMcM5fjUz5c5xQFPhYdq3HFEsOiakpBumMy17al4vODq6OokvRGKy7T9ED4pZopuLnZTkvvyDw "PHP – Try It Online")
[Answer]
# JavaScript, 69 bytes
Recursively splits and joins based on place values stored in `k`. Inspired by [xnor's Python answer](https://codegolf.stackexchange.com/a/195181).
```
f=(n,k=1e3)=>n<20?+n||'':(n<k?'':f(n/k|0,k/10)+[k-10&&k])+f(n%k,k/10)
```
[Try it online!](https://tio.run/##PY7BCoMwEETvfoWXmoRoTdRKKVo/RDyIGGlXkqLiyX9PV1O7LPOGWRj23a7t3E2vzxKtd2tVSXUIpexTVj51kYiK620j5EF1ARVSUR3DJkKIpWC8hkiKIICGcTxcwMVWmYku/bz4Rvm1RyQJUcSh@a5JumvmEunOLkNkJ29/k7uCk@JHiesqdouuYZ6P0xk9m7G/jmag6niEMfsF "JavaScript (V8) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~34~~ ~~32~~ ~~31~~ 29 bytes
```
⪫Ｅ↨Ｎφ⪫Ｅ↨ι¹⁰⁰⪫↨λχ…0›Πλ﹪λχ100Ｉφ
```
[Try it online!](https://tio.run/##VY3PCsIwDMZfZfSUQoXu4h@8ucNQmOzgC8Ra2KC2JeuUPX3NqhdzSD6@/PLFDEgmoMu5p9EnuITRQ4cRTjhZOPs4p@v8vFsCqapaa83jnxmLz/bNkkdawP2IBqcEjhfNYpxthhBBaKGqliwmDuwpPGbzRTqWLqyntZZcqnqvTXCyWEXJKu@lPOa83e0POm9e7gM "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved 2 bytes thanks to @Grimmy. Saved a further byte by finding a better way to choose between `0` or the empty string from a boolean. Saved a further 2 bytes because `Base(l, 10)` conveniently returns an empty array when `l` is zero. Explanation:
```
   Ｎ                            Input number
  ↨ φ                           Convert to base 1000 as an array
 Ｅ                              Map over elements
        ι                       Current element
       ↨ ¹⁰⁰                    Convert to base 100 as an array
      Ｅ                         Map over elements
              λ                 Current element
             ↨ χ                Convert to base 10 as an array
            ⪫                   Join with
                 0              Literal `0`
                …               Truncated to length
                    λ           Current element
                   Π            Digital product
                  ›             Is greater than
                      λ         Current element
                     ﹪          Modulo
                       χ        Predefined variable 10
     ⪫                          Join with
                        100     Literal string `100`
⪫                               Join with
                            φ   Predefined variable 1000
                           Ｉ    Cast to string
```
Example: `67890` ⇒ `[67, 890]` ⇒ `[[67], [8, 90]]` ⇒ `[[607], [8, 90]]` ⇒ `[607, 810090]` ⇒ `6071000810090`.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~110~~ 115 bytes
```
def F(n,o=""):
 for i in 1000,100:
  if n>=i:o+=F(n//i)+str(i);n%=i
 return o+'0'[:0<n%10<=n>19].join(str(n))*(n>0)
```
[Try it online!](https://tio.run/##TZHBcoMgEIbP9SmYzGSAyjSLqIk25NiXyOSWOKWHJaP20Ke3u0q1l5/d//sHFnj@jJ8R3TTdH534UGii3@10m4ku9iKIgMICgCEhT4RO4MWHNuaesodD0Pkw9irod9z7kIn@MX73KGIuQV5bOOPewtnjxTa3t68YUHEatX5VeAE98RloBj7lqqwR0kpthLLAJcx1AUYWkOzZp2Vpa@7qJeWoLsAtwNqUs2m/GbOxRgpXJgsKEgfl6lcM2ARHUkK1kXrbhnlJUkGdhlvpP4/abRZYJM00wz8GK@S7qeZ05EeXDTknODKU@tZmL88@4EifRI@vZ/F@0NMv "Python 3 – Try It Online")
Pretty simple. Hundreds and thousands are handled recursively.
+5 bytes but fixed a bug with `F(100)` thanks to @ChasBrown.
[Answer]
# JavaScript, ~~95~~ ~~93~~ 92 bytes
```
f=n=>n>999?f(n/1e3|0)+[1e3]+f(n%1e3):n>99?(n/100|0)+'100'+f(n%100):n>20&&(x=n%10)?n-x+''+x:n
```
[Try it online!](https://tio.run/##PY7LCoMwEEX3foWbmoTUdnxUqqB@iLgQMaVFkqIiLvrv6YypDeGemzkw5NWt3dxPz/cSrndrVanLSld5nteK62s0JB8QskG2EgcnLKIgX5MFIMuQzFkAsjEEAd9Keotah5tkTG6FtspMfBnmxTfKbzwWsTMG7JlRxgll6iaR026GSA/e/iVzCw7CjxFet4IqtlZ4Pp7e6NmMw2U0D672jwhhvw "JavaScript (V8) – Try It Online")
---
* -2 bytes ([@Shaggy](https://codegolf.stackexchange.com/questions/195155/interpret-numbers-very-literally/195187?noredirect=1#comment464488_195187)): store `n%10` in a variable
* -1 byte ([@Arnauld](https://codegolf.stackexchange.com/questions/195155/interpret-numbers-very-literally/195187?noredirect=1#comment464518_195187)): replace `'1000'` with `[1e3]`
[Answer]
# [Python 2](https://docs.python.org/2/), ~~106~~ ~~105~~ ~~100~~ 107 bytes
```
f=lambda n:n/T and f(n/T)+`T`+f(n%T)or(n>=H)*`n/H*T+H`+'0'[:n%10>0<n%H>19].join(`n%H`)*(n%H>0)
H=100;T=1000
```
[Try it online!](https://tio.run/##TZHBboMwEETP5St8QbYBNWsbSKCFMx/ALYpkogiVql0ikku/nq7BhV7GM/NW1oLvP8@PEfU899VX9329dQxLPLSswxvrBTkZ29bGZMNWjpPAumpkZPHQRG3c2JgDP5cYKqjhHcOmVsXl9XMcUFhKVkbClSCDplIAb61TmPtxYpg82IDsLFTCuOIyYUKBs7B4DQnX4Oulp2ONuUv5OmXIazArUMrPKX/fgl2xjWiT@go0iYF06zMHXAmGJIVsJ/l@jeMpSQa5X26j/zqK@y6wit9pgX8MNui@TRSnI@WEF9Sc4Oggl5cyeLlPAz7pl9EzyEWq6hHMvw "Python 2 – Try It Online")
Saved 5 bytes adapting the `.join` approach of [randomdude999's](https://codegolf.stackexchange.com/a/195161/69880) answer; lost 7 bytes fixing a bug :).
]