[Question]
  [
## Input:
A list of integers
## Output:
Put each digit (and the minus sign) in its own lane, in the order `-0123456789`, ignoring any duplicated digits.
## Example:
Input: `[1,729,4728510,-3832,748129321,89842,-938744,0,11111]`
Output:
```
-0123456789  <- Added as clarification only, it's not part of the output
  1         
   2    7 9
 012 45 78 
-  23    8 
  1234  789
   2 4   89
-   34  789
 0         
  1        
```
## Challenge rules:
* Any duplicated digits in the number are ignored.
* I/O can be in any reasonable format. Input can be as a list/array of strings or character-array. Output can be as a list of strings, characters, character-matrix, etc.
* Trailing spaces are optional.
* Any amount of leading or trailing new-lines are optional (but not in between lines).
* Input will always contain at least one integer
* You'll have to support an integer range of at least `-2,147,483,648` though `2,147,483,647` (32-bit).
* The input-list will never contain `-0`, `00` (or more than two zeroes), or integers with leading zeroes (i.e. `012`).
* If you language uses a different symbol for negative numbers (like an upper `¯`), you are also allowed to use that instead, as long as it's consistent.
* You are allowed to have a space delimiter between digits (so a line without 5 or 8 can be `- 0 1 2 3 4 6 7 9` instead of `-01234 67 9`), as long as it's consistent (and therefore there should also be a space between `-` and `0`).
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.  
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code.
* Also, please add an explanation if necessary.
## Test cases:
```
Input: [1,729,4728510,-3832,748129321,89842,-938744,0,11111]
Output:
  1         
   2    7 9
 012 45 78 
-  23    8 
  1234  789
   2 4   89
-   34  789
 0         
  1        
Input: [4,534,4,4,53,26,71,835044,-3559534,-1027849356,-9,-99,-3459,-3459,-94593,-10234567859]
Output:
      4     
     345    
      4     
      4     
     3 5    
    2   6   
   1     7  
  0  345  8 
 -   345   9
 -0123456789
 -         9
 -         9
 -   345   9
 -   345   9
 -   345   9
 -0123456789
Input: [112,379,-3,409817,239087123,-96,0,895127308,-97140,923,-748]
Output:
  12       
   3    7 9
-  3       
 01 4   789
 0123   789
-      6  9
 0         
  123 5 789
-01  4  7 9
   23     9
-    4  78 
Input: [-15,-14,-13,-12,-11,10,-9,-8,-7,-5,-4,-3,-1,0,9,100,101,102,1103,104,105,106,116,-12345690]
Output:
- 1   5    
- 1  4     
- 1 3      
- 12       
- 1        
-01        
-         9
-        8 
-       7  
-     5    
-    4     
-   3      
- 1        
 0         
          9
 01        
 01        
 012       
 01 3      
 01  4     
 01   5    
 01    6   
  1    6   
-0123456  9
Input: [99,88,77,66,55,44,33,22,11,10,0,0,0,-941]
Output:
          9
         8 
        7  
       6   
      5    
     4     
    3      
   2       
  1        
 01        
 0         
 0         
 0         
- 1  4    9
```
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
### Code:
```
v'-žh«DyмSð:,
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f@/TF336L6MQ6tdKi/sCT68wUrn//9oEx0FU2MgAUGmxjoKRmY6CuaGOgoWxqYGJkAxXWMLU0uwGl1DAyNzCxNLY1OgEl1LEAYRxiamSJQlkDKGqAWKmJkDNccCAA "05AB1E – Try It Online")
### Explanation:
```
v               # For each element in the input..
 '-žh«          #   Push -0123456789
      D         #   Duplicate this string
       yм       #   String subtraction with the current element
                    e.g. "-0123456789" "456" м  →  "-0123789"
         Sð:    #   Replace all remaining elements with spaces
                    e.g. "-0123456789" "-0123789" Sð:  →  "     456   "
            ,   #   Pop and print with a newline
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
║V≡u╝─é╢
```
[Run and debug it](https://staxlang.xyz/#p=ba56f075bcc482b6&i=4%0A534%0A4%0A4%0A53%0A26%0A71%0A835044%0A-3559534%0A-1027849356%0A-9%0A-99%0A-3459%0A-3459%0A-94593%0A-10234567859&a=1)
It takes one number per line on standard input. It works by finding the target index of each character and assigning it into that index of the result. If the index is out of bounds, the array is expanded with zeroes until it fits. During output, `0` becomes a space. The rest are character codes.
Unpacked, ungolfed, and commented, this is what it looks like.
```
m       for each line of input, execute the rest of the program and print the result
 zs     put an empty array under the line of input
 F      for each character code in the line of input, run the rest of the program
  Vd    "0123456789"
  I^    get the index of the character in this string and increment
  _&    assign this character to that index in the original string
```
[Run this one](https://staxlang.xyz/#c=m++++++%09for+each+line+of+input,+execute+the+rest+of+the+program+and+print+the+result%0A+zs++++%09put+an+empty+array+under+the+line+of+input%0A+F+++++%09for+each+character+code+in+the+line+of+input,+run+the+rest+of+the+program%0A++Vd%09%220123456789%22%0A++I%5E+%09get+the+index+of+the+character+in+this+string+and+increment%0A++_%26+++%09assign+this+character+to+that+index+in+the+original+string&i=4%0A534%0A4%0A4%0A53%0A26%0A71%0A835044%0A-3559534%0A-1027849356%0A-9%0A-99%0A-3459%0A-3459%0A-94593%0A-10234567859&a=1)
[Answer]
# [Haskell](https://www.haskell.org/), 51 bytes
*-1 byte thanks to [Laikoni](/u/56433).*
```
f l=[[last$' ':[n|n`elem`i]|n<-"-0123456789"]|i<-l]
```
[Try it online!](https://tio.run/##PY7BCoMwEER/ZRHBywbUJJoU/YoeQ8AcIobGVBqlF/89jS2U3TcszMLMYuLDep/SDH5Uypu4lxVUNxXOMFlv18npMwykIHXTUsa7XshCn24gXqfVuAAjbMd@319QwhG8Czbma86sZoO4PN@gGHLK8BpOse2wb1BQXjOGhAouL5M0ddsLJinvkMi8mRz3V5mVfr9@JbjU6QM "Haskell – Try It Online")
This challenge is digitist. D:
[Answer]
# JavaScript, ~~59~~ 58 bytes
Input & output as an array of strings.
```
a=>a.map(x=>`-0123456789`.replace(eval(`/[^${x}]/g`),` `))
```
---
## Try it
```
o.innerText=(g=s=>(f=
a=>a.map(x=>`-0123456789`.replace(eval(`/[^${x}]/g`),` `))
)(s.split`,`).join`\n`)(i.value="1,729,4728510,-3832,748129321,89842,-938744,0,11111");oninput=_=>o.innerText=g(i.value)
```
```
input{width:100%;}
```
```
<input id=i><pre id=o></pre>
```
---
## Original
Takes input as an array of strings and outputs an array of character arrays
```
a=>a.map(x=>[...`-0123456789`].map(y=>-~x.search(y)?y:` `))
```
```
o.innerText=(g=s=>(f=
a=>a.map(x=>[...`-0123456789`].map(y=>-~x.search(y)?y:` `))
)(s.split`,`).map(x=>x.join``).join`\n`)(i.value="1,729,4728510,-3832,748129321,89842,-938744,0,11111");oninput=_=>o.innerText=g(i.value)
```
```
input{width:100%;}
```
```
<input id=i><pre id=o></pre>
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~32~~ 12 bytes
*28 bytes saved thanks to @Adám and @ngn*
```
⊃¨⎕∘.∩'¯',⎕d
```
[Try it online!](https://tio.run/##ZVA7TgNBDO1zCnfbABr/xnbBYSJFoYkELTUFERJ0kThCqPYOe5S9SLAnQkLKjDze9ec9P29fDve71@3h@emyHt/3l/XjbTmvX6f1@P2wHn@mZZ7u8ndX2ct@s36eljMgGAWIkSs2WGZ2JjBxpGBC8HChDAe7iUADrLOZHutMmz8UAWUBGR6og2Una8uORFSNyi4zNjKXYO2FWFYPi/5zkY6vtRnp5ho3bIgEbKMJpIWjAXE0N6RqjZ5zeiiScfMKGEqDGMmUdoOXbFrPmHGQl2REGBspnkKxtCobmiqfLJEluZNWpZRzNc4PSdO0noE@0EpJtBvelO8OZtA7qEJui3N7hVPM11sbwV8 "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~17~~ 13 bytes
Saved 4 bytes thanks to *Adnan*
```
vðTúyvyÐd+ǝ},
```
[Try it online!](https://tio.run/##MzBNTDJM/f@/7PCGkMO7KssqD09I0T4@t1bn//9oQx1zI0sdE3MjC1NDAx1dYwtjIx1zEwtDI0tjI0MdC0sLEyMdXUtjC3MTEx0DHUMQiAUA "05AB1E – Try It Online")
**Explanation**
```
v               # loop over elements y in input
 ðTú            # push a space prepended by 10 spaces
    yv          # for each element y in the outer y
      y         # push y
       Ðd+      # push y+isdigit(y)
          ǝ     # insert y at this position in the space-string
           }    # end inner loop
            ,   # print
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 42 bytes
Anonymous lambda processing the array of numbers:
```
->a{a.map{|n|"-0123456789".tr"^#{n}",?\s}}
```
[Try it online!](https://tio.run/##FcFLDoIwEADQq5i6nZLOB2e6UA8CmNQFOwnhsyClZ6/hvWX/HnV8Vv9KOTW/NOdzOp0PSCztQy26Zlvc556n4uDdr6XUed/W29h1CEoRRMlaDODZmEDFkCITgkUTAh/ZVAQC4GUY6h8 "Ruby – Try It Online")
Alternatively, a completely Perl-like full program is much shorter. I'd say `-pl` switches look quite funny in this context:
# [Ruby](https://www.ruby-lang.org/) `-pl`, 29 bytes
```
$_="-0123456789".tr"^#$_"," "
```
[Try it online!](https://tio.run/##FcE5DoNADADA3q@IDCUbrQ@wXfAVkNJFigLiKPJ5HDGzna9fZjuPWCqxaD@YBz6PDaemnbHDB2YSGAeosfdUoYgLg6kThzCBhytDCXFThQp0u5b1eC/fPcv6@QM "Ruby – Try It Online")
Finally, the following is possible if it is acceptable for the output strings to be quoted:
# [Ruby](https://www.ruby-lang.org/) `-n`, 27 bytes
```
p"-0123456789".tr ?^+$_,?\s
```
[Try it online!](https://tio.run/##FcE7DoMwDADQ3adAiA1SxR9qe8pFUCt1YwmI0KGXx6jvHd/PL2LvU0ZimZ9q3j/OoyuvcXhPZWkRCEoOomQzZkhsTKBiSM6EYG5CkJxNRSAD/l3bfq5bbZHqDQ "Ruby – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 60 bytes
* Thank to @Andrew Taylor for reducing the join (8 chars)
* Thank to @Yair Rand for X.match (8 chars)
```
a=>a.map(X=>"-0123456789".replace(/./g,x=>X.match(x)?x:" "))
```
[Try it online!](https://tio.run/##PY7NCsMgEIRfpXhSquZHN4kF09cIlB7E2rQljSEJxbe3JoUyO3PZgW9e5mMWOz@nlY3@5uJdR6Nbw99mwp1uEcuLUkio6kYhPrtpMNbhjGc9DbrtUm21DxzIOZzQARESrR8XPzg@@B7f8UVSEJJuAkHLitYFbQTkUlImANT2ZEVe1o1UAirKVLrkRPynSin21m8HqOu@LvHDESUmiV8 "JavaScript (Node.js) – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 16 bytes
Input & output as an array of strings.
```
£Ao ¬i- ®iS gXøZ
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=o0FvIKxpLSCuaVMgZ1j4Wg==&input=WyIxIiwiNzI5IiwiNDcyODUxMCIsIi0zODMyIiwiNzQ4MTI5MzIxIiwiODk4NDIiLCItOTM4NzQ0IiwiMCIsIjExMTExIl0KLVI=)
---
## Explanation
```
£                    :Map over each element X
 Ao                  :  Range [0,10)
    ¬                :  Join to a string
     i-              :  Prepend "-"
        ®            :  Map over each character Z
         iS          :    Prepend a space
            g        :    Get the character at index
             XøZ     :      X contains Z? (true=1, false=0)
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~77~~ 64 bytes
*-12 bytes thanks to @Rod*
```
lambda x:[[[" ",z][z in str(y)]for z in"-0123456789"]for y in x]
```
[Try it online!](https://tio.run/##PVHJbsIwEL3zFVYuJNK48r4g8SUmhyBaNQgMghwCP5@@AVQ7YyV@29i5PqbfS7XLsN0tp@G8Pwxi3pRSGtHQsy9PMVZxn27to@t/LjfB341U2ljnQ0y5ee0@mDX3SxVbUYojbx3x9JZMoKgpWa@cI2m9zwxKrUxMLlsfSGY8KDj@rxmrfbHeOT73tCqaosnkokleK1CTNRRd0iZbg4ycnIHUpogoRZoHy2CeEsVIIZD3BNCiLwMCweY9kfjiSu0Ryw1yPOzeJO4xkYwkAfM5AECVgSFIMYf9lMWLQ3lUwEZgEz5CVn2/WvFdzXxXdSOut7FO7XpX11/Hy1jb03if2vNwbT9/Yb9Zf5B9R2Jo5w6DvuthCw1U3fIH "Python 3 – Try It Online")
My first proper attempt at golfing in Python. Advice welcome!
Returns a 2D array of characters.
[Answer]
# [Perl 5](https://www.perl.org/) `-pl`, 33 bytes
```
$_=eval"'-0123456789'=~y/$_/ /cr"
```
[Try it online!](https://tio.run/##PU3LCsIwELzvV0gp9LTmsdkke@gn@A1FpAch2FCL4MVPd00VZB6XGWbqvBZW7adxfpxLN6B1ngLHlGUYX0/TT@ZgLmunGoApwA4m8BGSg0xsQwAkZtlDdNanHIQ4AkpjUxv7uzSnb@t3wfJe6nZdbnfFEx@ts4q1fAA "Perl 5 – Try It Online")
Takes input as line separated.
[Answer]
# [Haskell](https://www.haskell.org/), 47 bytes
```
map(\s->do d<-"-0123456789";max" "[d|elem d s])
```
[Try it online!](https://tio.run/##PU5BCoMwEPzKEnpoIQE1iSa09hM9qodgYpVGDY3SHvr2prGFsjPDwgyz2yt/M9aGrqzDqNy@9uSsZ9AngkiSZpTxvBASHUf1RIAq/TLWjKDBN4eYHyYowa3LZbnDDtbJDpPxcesiYxv4fn5AxTCnDG/DKc5yXKRYUJ4whgkVXG4mSZOsEExSnmMiIyLj7b/KqPSb@n3EZRPebWfV1QfSOvcB "Haskell – Try It Online")
Uses `max` to insert a space where no element exist, since a space is smaller than any digit or minus sign.
If an ungodly number of trailing spaces is OK, two bytes can be saved:
**45 bytes**
```
map(\s->do d<-'-':['0'..];max" "[d|elem d s])
```
[Try it online!](https://tio.run/##PUzLDoIwEPyVDTFBk5YAbXmo@BMegUNDQYgFGgvRg99uXTyYnZnMZme2l/beau26onKjNPvK0ouaQZ2pT/1j6Yd@ENSnUb488Er1bnU7ggJbHzA9TFCAWZfr8oAdrJMeptai65D4C2w/P6HkRDBOthGMxAlJI5IxEXJOKMtEvh1pFMZpxnMmEkJzBJJx8dcclf1SuCcptmr3aTotb9bRxpgv "Haskell – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 13 bytes
```
"45KY2ht@gm*c
```
Input is a cell array of strings. [Try it online!](https://tio.run/##y00syfn/X8nE1DvSKKPEIT1XK/n//2p1Q3UddXMjSyBpYm5kYWpoAGTpGlsYG4HETSwMjSyNjUBqLCwtTEBiupbGFuYmJkAWSKUhCKjXAgA "MATL – Try It Online") Or [verify all test cases](https://tio.run/##VVG7TsQwEOz5DBpLCEvel73bUdDRUkCBBLoCCq677sS3B@84kSCSx85kdmc9OX9cvrf37Vbt6ZW/Lg@f57vT9kbt9PL4vF0LlfsyOCbqYDdq81TFhZNXJw7h1Hi4JldDfKjOUyopn/Jzcy3JmCQey2QC9@yDBmINdVXMYkkrNR6uIdbRGgAUtX97zF32isn14ZNPX6KcSsZSp3ULp5HWEs0HMcqi7xN7GPGQ5mAHaZKxRPO@6FnJYLVGXLa4O@VFVkTwQ5P0qijQY4ZKu1tAj6TaqmWk1gQvCjRgx4e@zPKK0TAM8vB0GunUU2FZgjAFIa@mx2x/1wxu/p9f).
### Explanation
```
         % Implicit input: cell array of strings, for example {'1','729',...,'11111'}
"        % For each cell
  45     %   Push 45 (ASCII code of '-')
  KY2    %   Push predefined literal '0123456789'
  h      %   Concatenate horizontally: gives '-0123456789'
  t      %   Duplicate
  @      %   Push current cell, for example {'729'}
  g      %   Convert cell to matrix. This effectively gives the cell's contents, '729'
  m      %   Ismember: gives an array of zeros and ones indicating membership of each
         %   char from '-0123456789' in '729'. The result in the example is
         %   [0 0 0 1 0 0 0 0 1 0 1]
  *      %   Multiply, element-wise. Chars are implicity converted to ASCII 
         %   Gives the array [0 0 0 50 0 0 0 0 55 0 57] 
  c      %   Convert ASCII codes to chars. 0 is displayed as space. Gives the string
         %   '   2    7 9'
         % Implicit end
         % Implicilly display each string on a different line
```
[Answer]
# [J](http://jsoftware.com/), 32 27 bytes
-5 bytes thanks to FrownyFrog!
```
10|.":(10<."."0@[)}11$' '"0
```
[Try it online!](https://tio.run/##XU7LSgQxELzPVxSDGBd06E53XoOKIHjy5NVDDouL7GV/QL99rKywgiHVeVRXdR23eQkHPKwIuIVgJe4WPL@9vmwqX8u83qjcL/Myy9P77lv1KiDMsu0mTB/7zxMO148oscFLrEkF3apFFK8am0VFbdUjerNa3GmuY/1KQ/izcCRz@PlEzChUWhJKuqXUBtlVYqneLGX6cRPm6VIbq527@M6lpvZvDDinayKG2WhlMFWM1NRX9IJOeswkwbCNHCPL6ImMLsaLE4nI/MjDZIxrgsuath8 "J – Try It Online")
## Original solution:
# [J](http://jsoftware.com/), 32 bytes
```
(('_0123456789'i.[)}11$' '"0)@":
```
## Explanation:
`@":` convert to characters and
`}11$' '"0` change the content of an array of 11 spaces to these characters
`'_0123456789'i.[` at the places, indicated by the indices of the characters in this list
[Try it online!](https://tio.run/##XU7LSgQxELzPVxSDmB3QIZ3uPHpAEQRPnrx6yEFc1Itf4LePlV1YwSbVCamurvra5zUccbch4AYRG3G74vHl@Wk/HEKPktRyqc3D5/q6/IhcBYQ5Lg/zti8Tpve3j28cr@8hqMlhNbUsEV2bJlRrklyToHmzhO7aqhk9ZNRZHMLfEkNWg51upIJKpeZISdecfZBdYqrNXHPhPh6CES/d2fU0dQ6e/Z8N6NMlE2PZGGUwEYzU1Df0ik56eJJgWCfHyHHMJEaPyocRmSj8KGPJsPOIS037Lw "J – Try It Online")
[Answer]
# [Google Sheets](https://sheets.google.com), 124 bytes
```
=Transpose(ArrayFormula(If(IsError(Find(Mid("-0123456789",Row($1:$11),1),Split(A1,",")))," ",Mid("-0123456789",Row($1:$11),1
```
Input is a comma-separated list in cell `A1`. Output is in the range `B1:L?` where `?` is however many entries were input. (You can put the formula wherever you want, I just chose `B1` for convenience.) Note that Sheets will automatically add four closing parentheses to the end of the formula, saving us those four bytes.
[![Screenshot](https://i.stack.imgur.com/1M76F.png)](https://i.stack.imgur.com/1M76F.png)
Another [test case](https://i.stack.imgur.com/kZwXa.png) and another [test case](https://i.stack.imgur.com/XP6a9.png)
Explanation:
* `Mid("-0123456789",Row($1:$11),1)` picks out each of the 11 characters in turn.
* `Find(Mid(~),Split(A1,","))` looks for those characters in each of the input elements. This either returns a numeric value or, if it's not found, an error.
* `If(IsError(Find(~)," ",Mid(~))` will return a space if the character wasn't found or the character if it was. (I wish there was a way to avoid duplicating the `Mid(~)` portion but I don't know of one.)
* `ArrayFormula(If(~))` is what makes the multi-cell references in `Mid(~)` and `Find(~)` work. It's also what makes a formula in one cell return values in multiple cells.
* `Transpose(ArrayFormula(~))` transpose the returned array because it starts off sideways.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
ØD”-;¹⁶e?€Ʋ€
```
[Try it online!](https://tio.run/##y0rNyan8///wDJdHDXN1rQ/tfNS4LdX@UdOaY5uAxP@HO/cBqcPtkf//R5vomBqb6ICgqbGOkZmOuaGOhbGpgYmJjq6xqaklSFLX0MDI3MLE0tjUTEfXEoiA2NjEFE5aAkljsCog38zcwtQyFgA "Jelly – Try It Online")
-2 thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan) reading a rule I didn't.
Note that the I/O format used in the TIO link is not the actual one, which is input as a list of string representations and output as a list of lines.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 35 bytes
```
{.map:{map {m/$^a/||' '},'-',|^10}}
```
[Try it online!](https://tio.run/##PVBdb8IwDHzefkWF0AqSA3GcxPGk8Uc2mHgY0qbxIfaEgN/enTtpTe02vfPlrqeP83cd9pfuade9DNfFfnt6vqJ11/1yutkub7e@6@/Uh55uG473@/CzvXS72fR9vlotvo6fh7HNJm@HyZw6f3S74/nx4ZVJk1HW1ApHCtIkkebGySQxNWs5UTBpmjNFYr/WhLlMRTL5KkKpkoIsJYIVpBRzMHBM2rJJqZDAjZJc/ruhy8jCvmorNiozJxJ1FuVojZWSWGzKCWSrcNGscFKJDXvlHMkcgutxPnCBqB/v4nDPTB4NihhQCoDdJQBoGTDkis5JyBcFLxlVUBUfqou4QYujPFK0RqpUK5VCCCz4AT7qp/wtROP18As "Perl 6 – Try It Online")
Output is a character matrix containing either regex matches or space characters.
[Answer]
# Java 8, 53 bytes
```
a->a.map(i->"-0123456789".replaceAll("[^"+i+"]"," "))
```
My own challenge is easier than I thought it would be when I made it..
Input and output both as a `java.util.stream.Stream<String>`.
**Explanation:**
[Try it online.](https://tio.run/##lVLBatwwEL3nK4RONqmEZUmW1LQL@YCmhxxDCsrGG7z12outDYSy376dGXnbLrSUGDSypZn33jzPNr5GsX3@flr3cZ7Zl9gNP64Y64bUTpu4btkdfjK2hTx5SF0v5zS1cSfvafsEWze8rNi6@F9GLG8A6XgFYU4xdWt2xwb2mZ2iWEW5i/uiEysuKlVrYxvnA5dTu@9Bw23fF/zhG7/urvkj/8AZL8vTDQLtD089AC14r2P3zHbQQZE5Hx6BNMtP7ZwKrqDY1QGicbW3qoI3ob2u8dx4VQddY44P3uCZCNo7Y@ANMxU@nLo4A@KV1RjPy2oIdYOAhKRtRQBCWxtyqlBV7bwJ2jbEQYEiNH6xB9j1UqENeALHF/xKoUztchVKqIJXDiXoUHkHXhJOs7Tgg1W105WnU6cMHoacBAZcggtliTtrzjrIFYWdZfOImNCQVFCBOYsRaqENlE8eVrm2Jj8rTR@GoqXY0EWTyXAQQnWpipzySOmQssFUi7Vksyb7M/pZ5J8LLF1@4RHW71Gk0SGCPDpSyl@zsxmn4uvTtl0nNrKPbJD/nHU5bopYljKNt9MU34qyJADG7t/m1ML1Ick9wKd@KMalq79ccfHu59zT8fQT)
```
a->                              // Method with String-Stream as both input and return-type
  a.map(i->                      //  For every String in the input:
    "-0123456789"                //   Replace it with "-0123456789",
    .replaceAll("[^"+i+"]"," ")) //   with every character not in `i` replaced with a space
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 159 bytes
```
f(A,l,j,k,b)long*A,k;{char*s,S[99];for(j=~0;++j<l;puts(""))for(sprintf(S,"%ld",k=A[j]),putchar(k<0?45:32),k=47;++k<58;putchar(b?32:k))for(b=s=S;*s;b*=*s++-k);}
```
[Try it online!](https://tio.run/##dZHdbuIwEIWvt4@BtFIcJpLH47@piSqegUvERaGiW0JpRbpXKPvq7PFWW6kXxLEV@4y/mTnZdc@73fW6b5Z0pAMNtDXHt9Nzu6ShXHa/Hs/tSKu16qbs387Nof9jy3x@WBzL@@@PsZnNjKnn4/v55fSxb1Y0@3l8mtHQL9eHjSEEVUYzLOyDD/fiDCSfgBgWIZf/8vZB3P3widr2Y78q7Vi2bd@O83k3mDJdXx9fTo253P3YN02tb70xF6bklHxyObClTrI4Sj6zU3FMWbN31Knk5D1Z4vpMpOar8vKN5imIpzqCkIuUgJBgcbeTELSKHVuXslcJEWC8mOLD16pY5V8U9jHloBNxvJWQ2ZGkepm81cyJnKjNiR0YGlFy1sAuic3YJ/aWtEpoEVi@he04oIRabC0FDjBTtQeJwEnUQa49QUAKhQZvbI1xoFrBh8cMmBEHsUJqO2oncv5WVliRM6VEMVIIBNcELlZiTf454A9@AH9jTNe/ "C (gcc) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~96~~ 75 bytes
```
for(i in scan())cat(paste(gsub(paste0("[^",i,"]")," ","-0123456789"),"\n"))
```
[Try it online!](https://tio.run/##JchNCgMhDEDhfU4hWSkomJip8Sz9ATu0xY0t4/T8lqFv9fG2OZ/vzTbTuhlr7da5te72U8f@sK/xvf8ZLZ5v6JvHKzqPBj2GSJxkOWUtx7p0dG4SZC4gmXWhCCFpYsiixCUxgRYVhlCSZhGIQEfzBw "R – Try It Online")
Thanks to Kevin Cruijssen for suggesting this regex approach! 
Takes input from stdin as whitespace separated integers, and prints the ascii-art to stdout.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), ~~14~~ 13 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
{ø,{²²⁴WI1ž}P
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JTdCJUY4JTJDJTdCJUIyJUIyJXUyMDc0V0kxJXUwMTdFJTdEUA__,inputs=MTYlMEE0JTBBNTM0JTBBNCUwQTQlMEE1MyUwQTI2JTBBNzElMEE4MzUwNDQlMEEtMzU1OTUzNCUwQS0xMDI3ODQ5MzU2JTBBLTklMEEtOTklMEEtMzQ1OSUwQS0zNDU5JTBBLTk0NTkzJTBBLTEwMjM0NTY3ODU5,v=0.12)
Explanation:
```
{ø,{²²⁴WI1ž}P
{            repeat input times
 ø,            push an empty string and the next input above that
   {       }   for each character in the input
    ²²           push "0123456789"
      ⁴          copy the character on top
       W         and get it's index in that string (1-indexed, 0 for the non-existent "-")
        I        increment that (SOGL is 1-indexed, so this is required)
         1ž      at coordinates (index; 1) in the string pushed earlier, insert that original copy of the character
            P  print the current line
```
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), 85 bytes
```
I	X =INPUT	:F(END)
	S ='-0123456789'
R	S NOTANY(X ' ') =' '	:S(R)
	OUTPUT =S	:(I)
END
```
[Try it online!](https://tio.run/##PY67CsMwDEVn6yu82RkMcSQldiBDoS14cUoekK6dSzP0/3GVFoqkO0jnSnq/9sf@pFKS2vSQ8m1dVH@1l3yuQM16MK72DRK3XYgGJmnlcTnlu9200aYSQBvVz3YSfFwXsethVr1NFciOUggYCY5ghKaFzkNAronAIXM8hs7XTRcoIrfgoqSUXPxrFMUv9fuD4wc "SNOBOL4 (CSNOBOL4) – Try It Online")
```
I	X =INPUT	:F(END)		;* read input, if none, goto end
	S ='-0123456789'		;* set the string
R	S NOTANY(X ' ') =' '	:S(R)	;* replace characters of S not in X + space with space
	OUTPUT =S	:(I)		;* print S, goto I
END
```
[Answer]
# Pyth, 14 bytes
```
VQm*d}dNs+\-UT
```
Takes input as list of strings and outputs a list of strings for each line.  
[Try it here](http://pyth.herokuapp.com/?code=VQm%2Ad%7DdNs%2B%5C-UT&input=%5B%224%22%2C%20%22534%22%2C%20%224%22%2C%20%224%22%2C%20%2253%22%2C%20%2226%22%2C%20%2271%22%2C%20%22835044%22%2C%20%22-3559534%22%2C%20%22-1027849356%22%2C%20%22-9%22%2C%20%22-99%22%2C%20%22-3459%22%2C%20%22-3459%22%2C%20%22-94593%22%2C%20%22-10234567859%22%5D&debug=0)
### Explanation
```
VQm*d}dNs+\-UT
VQ                For each string in the input...
  m     s+\-UT    ... and each character in "-0123456789"...
     }dN          ... check if the character is in the string...
   *d             ... and get that character or an empty string.
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 26 bytes
```
%"-0123456789"~`.+
[^$&]¶ 
```
[Try it online!](https://tio.run/##K0otycxLNPz/X1VJ18DQyNjE1MzcwlKpLkFPmys6TkUt9tA2hf//TbhMjU24QNDUmMvIjMvckMvC2NTAxIRL19jC1BIkqWtoYGRuYWJpbGrGpWsJREAMNA1OWgJJY7AqiB2mlgA "Retina – Try It Online") Note: Trailing space. Explanation: `%` executes its child stage `~` once for each line of input. `~` first executes its child stage, which wraps the line in `[^` and `]<CR><SP>`, producing a program that replaces characters not in the line with spaces. The `"-0123456789"` specifies that the input to that program is the given string (`$` substitutions are allowed but I don't need them).
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, 30 bytes
Wouldn't work if `-` could appear anywhere else than in the first position
```
#!/usr/bin/perl -n
say"-0123456789"=~s/[^$_]/ /gr
```
[Try it online!](https://tio.run/##PU27CsJAEOz3KyTYrvfY3bvbIp/gF4iKhYggScjZ2Pjpbi4KMo9mhpnpOj/ErF5eHfoQiSXlol3/ru5w2p6PbuNusxmDEMMKIYgJcoBC4pkBSUTXEIOPubCSJEBtbGpzf9fm9G39TkQ/4/S8j0M13MvOB284LA "Perl 5 – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 94 bytes
```
func[b][foreach a b[s: copy"           "foreach c a[s/(index? find"-0123456789"c): c]print s]]
```
Takes input as a block of strings
[Try it online!](https://tio.run/##TU4xDsIwDNz7CssTDBWNnZCEhT@wRhlK2giWFrUgweuLQ4XAin3S@XyXqe@WU99BiFU@LPkxpHCOIY9T36YLtHAO8wHSeHsh/Aq/@wRtmHeb69D1zyNkQawbRazN3jqPaSu38TZdhzvMMS4ZAmpEwzLWZxiR9ohWITo2jRauZmP8R1OrhqzTno1Ial@6DLH/Ay/Aq3bNFTZWayhiVTLF3JJotSVnVFNuHZOQ2inyTCXcO03FjZ0tnxCRKoVxeQM "Red – Try It Online")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 20 bytes
```
qS%{'-10,+s_@-SerN}/
```
[Try it online!](https://tio.run/##FcE9DkBgDADQq3QRA42vP9J2cwKLA4iIRWLAKM5e8d66L0fmOVVPjVTa5p4HnLZrfLtMAuMANfaeCqC4MJg6cQgTeLgyYIibKhSg3wc "CJam – Try It Online")
Accepts input as space separated list of integers. Pretty much the same approach as @adnans answer.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~95~~ 94 bytes
```
c,d;f(l,n)char**l;{for(;n--;l++)for(c=0;c<12;)putchar(strchr(*l,d=c++?c+46:45)?d:d^58?32:10);}
```
[Try it online!](https://tio.run/##VVLbbsMgDH1uvgLlKWlAwhgCNKv6IbtIE9G6Slk2td1eqn57h02qaZFisDk@PjYktU/pdktyHN6aSc5ten89rtfTcHn7PDbDrNQwdV1LTtrqIT2AGdqv7zPBmtP5mN6PzXqS4zZ13S51tt9Y1@7Gzfjiwg7NBnQ7XG8/n4dR7BtKEplcisN8FnNbXaoVVc3boVpl1lNTP@WSStU5cK0qgn28HuaGoSV9OpzOj89iKy411LL2JmZrvQkOdN4pDGgobgOYiIYwIQZLMRUxeGvzjpBAX32VzGgWSjp0SPb@O8zG9ETJXOg0Uyh0LhaoAm18sBFdz1XYsEXr/q0xr7hk5FjvQ44vEvDeFZBW9CWRVOgYwJMKjDp4MMwQ@6WPEB0Yjzpw1IOlYCygPIU7vV3oFTgWUIQXMTwcoPbKDLk081FZxQn2LkfBUjgynkepS67hsWpkx7J1bHs@6Esxajzq@prvvFrtGxInRaQnUBwjBfR/LmYX/lwrhbH0PG6/ "C (gcc) – Try It Online")
Input in the form of a list of strings. Output to STDOUT.
[Answer]
# [K4](http://kx.com/download/), ~~30~~ 27 bytes
**Solution:**
```
{?[a in$x;a:"-",.Q.n;" "]}'
```
**Example:**
```
q)k){?[a in$x;a:"-",.Q.n;" "]}'1 729 4728510 -3832 748129321 89842 -938744 0 11111
"  1        "
"   2    7 9"
" 012 45 78 "
"-  23    8 "
"  1234  789"
"   2 4   89"
"-   34  789"
" 0         "
"  1        "
```
**Explanation:**
Return "-0123..." or " " based on the input. Interpreted right-to-left. No competition for the APL answer :(
```
{?[a in$x;a:"-",.Q.n;" "]}' / the solution
{                        }' / lambda for each
 ?[      ;          ;   ]   / if[cond;true;false]
                .Q.n        / string "0123456789"
            "-",            / join with "-"
          a:                / save as a
       $x                   / convert input to string
   a in                     / return boolean list where each a in x
                     " "    / whitespace (return when false)
```
[Answer]
# APL+WIN, 33 bytes
Prompts for screen input as a string
```
n←11⍴' '⋄n['-0123456789'⍳s]←s←⎕⋄n
```
]