[Question]
  [
*Also known as the [analog root]*
([Opposite of the digital root!](https://codegolf.stackexchange.com/questions/123258/opposite-of-the-digital-root?answertab=active#comment302444_123258)) ;)
The digital root of a number is the continuous summation of its digits until it is a single digit, for example, the digital root of 89456 is calculated like this:
8 + 9 + 4 + 5 + 6 = 32
3 + 2 = 5
The digital root of 89456 is 5.
Given a digit as input via **STDIN**, print/return all of the possible two digit numbers that have that digital root. If you need it to, it can include itself, e.g. 05
These are all of the possible inputs and outputs:
**(You get to choose whether or not to include the leading zero for the digit itself)**
## I/O
**0** => 0 or 00 or nothing
**1** => 01 and/or 1, 10, 19, 28, 37, 46, 55, 64, 73, 82, 91 - **Make sure that 1 does not return 100**
**2** => 02 and/or 2, 11, 20, 29, 38, 47, 56, 65, 74, 83, 92
**3** => 03 and/or 3, 12, 21, 30, 39, 48, 57, 66, 75, 84, 93
**4** => 04 and/or 4, 13, 22, 31, 40, 49, 58, 67, 76, 85, 94
**5** => 05 and/or 5, 14, 23, 32, 41, 50 ,59, 68, 77, 86, 95
**6** => 06 and/or 6, 15, 24, 33, 42, 51, 60, 69, 78, 87, 96
**7** => 07 and/or 7, 16, 25, 34, 43, 52, 61, 70, 79, 88, 97
**8** => 08 and/or 8, 17, 26, 35, 44, 53, 62, 71, 80, 89, 98
**9** => 09 and/or 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99
No [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default), and it's [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins.
> 
> Congrats to [Heeby Jeeby Man](https://codegolf.stackexchange.com/users/56656/heeby-jeeby-man) on [his amazing 46 byte brain-flak answer!](https://codegolf.stackexchange.com/a/153072/69912)
> 
> 
> 
  
[Answer]
## JavaScript (ES6), ~~27~~ ~~31~~ 30 bytes
Returns `0` for `0` or an array of solutions otherwise.
```
n=>n&&[...1e9+''].map(_=>n+=9)
```
### Demo
```
let f =
n=>n&&[...1e9+''].map(_=>n+=9)
for(n = 0; n < 10; n++) {
  console.log(n, JSON.stringify(f(n)));
}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~13~~ ~~12~~ 9 bytes
-3 bytes thanks to Adnan
```
тL<ʒSOSOQ
```
[Try it online!](https://tio.run/nexus/05ab1e#@3@xycfm1KRg/2D/wP//TQE "05AB1E – TIO Nexus")
## Explanation
```
тL<ʒSOSOQ   Main link. Argument n
тL<         List from 1 to 100, then decrement to get 0 to 99
   ʒ        Filter
    SOSO    Sum of all chars, twice
        Q   Compare to input
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
11Ḷ×9+ȧ@
```
[Try it online!](https://tio.run/##y0rNyan8/9/Q8OGObYenW2qfWO7w//9/SwA "Jelly – Try It Online")
Different algorithm than my other answer.
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), 46 bytes
```
{((()()()()()){}){(({}[()])<(({}{}[]))>)}}{}{}
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/v1pDQ0MTBjWrazWBAtW10RqasZo2IBaQHaupaadZWwti//9vCgA "Brain-Flak – Try It Online")
## Explanation
This answer uses an idea from [Megatom's answer](https://codegolf.stackexchange.com/a/153112/56656) namely using the stack height as the difference between the loop counter and the increment. Like previous answers this answer has a large outer loop to catch all the zeros. Inside the loop we push 10 to act as a counter, we then start another nested loop. In this loop we decrement the counter by 1
```
({}[()])
```
Then we pop the top two items, which are the counter and the last item we calculated. We add these to the stack height in order to counter balance the decrementation, we then push this twice, once for output and once so that it can be consumed to calculate the next result. Pushing things twice means we accidentally push an additional value which needs to be removed at the end of execution.
The reason this just barely beats Megatom is Megatom's answer is forced to get its stack heights while the last result is still on the stack. This means they are forced to use a rather expensive `[()]` to decrease the total by one. By moving the duplicate to the end of the loop I am able to avoid having to use `[()]` at the cost of an additional `{}` at the very end of the program. If Megatom were to use this strategy his answer would look like:
```
{<>((()()()()()){}){((({}[()])<>{}[]))<>}}<>{}
```
also 46 bytes.
# [Brain-Flak](https://github.com/Flakheads/BrainHack), 52 bytes
```
{((()()()()()){}){({}[()]<(({})((()()())){}{})>)}}{}
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v@/WkNDQxMGNatrNas1qmujNTRjbTSADE2YLEgKyLXTrAVS//8b/TcEAA "Brain-Flak (BrainHack) – Try It Online")
## Explanation
The main outerloop makes a special case for input of zero. If zero is input we jump over the entire loop, pop zero and then output nothing. Otherwise we enter the loop. Here we push loop 10 times each time adding 9 to the top of the stack, keeping old values. Since 9 preserves digital sums this will get us the next value. Once the loop has expired we use the zero it generated to exit the loop which is then popped by the `{}` at the end.
# [Brain-Flak](https://github.com/Flakheads/BrainHack), 56 bytes
```
{([(((()()())){}{})]){({}()<(({})<(({}{}))>)>)}}{}({}{})
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v@/WiNaAwg0QVBTs7q2ulYzVrNao7pWQ9NGA0hBSCCtaQeEtUAWhPv/v9F/QwA "Brain-Flak (BrainHack) – Try It Online")
## Explanation
This version works very similarly to the last one, except we loop 9 times instead of 10 leaving out the original value. In order to do this we have to rearrange the way we handle memory a bit. All of the bytes we might have saved using this method get put into cleanup.
[Answer]
# [Haskell](https://www.haskell.org/), 21 bytes
`f` takes an integer and returns a list of integers.
```
f d=[d,d+9..99^0^0^d]
```
[Try it online!](https://tio.run/nexus/haskell#DcJLCoAgFAXQrdxBg6J49C8HrSQKpKckpIUWLd/iHCuNm4y7lZfbnTzuME4FsvJKw36@pMkryRm9p@cQNXiaueBcEAmxlj9eYixRoUaDFh16DBghPg "Haskell – TIO Nexus")
* Starts with the digit `d` and generates the range with every 9th number up to a bound of 99, *except* for the tricky case of `0`.
* To stop early for `0`, uses that the power `0^d==1` for `0` and `==0` for all other digits. Thus `99^0^0^d` gives `1` for `0` but `99` for anything else.
[Answer]
## Pyke, 6 bytes
```
ITV
9+
```
[Try it here!](http://pyke.catbus.co.uk/?code=ITV%0A9%2B&input=2&warnings=0)
```
ITV\n9+ - if input: (don't print anything for 0 case)
 TV\n9+ -  repeat 10 times:
   \n   -    print ^
     9+ -   ^ += 9
```
[Answer]
# [Python 2](https://docs.python.org/2/), 29 bytes
```
lambda n:n and range(n,100,9)
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqiQZ5WnkJiXolCUmJeeqpGnY2hgoGOp@b@gKDOvRCFNIzOvoLREQ1PzvyEA "Python 2 – TIO Nexus")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 12 bytes
```
0g|g{t+₉}ᵃ¹⁰
```
[Try it online!](https://tio.run/nexus/brachylog2#@2@QXpNeXaL9qKmz9uHW5kM7HzVu@P/f@H8UAA "Brachylog – TIO Nexus")
### Explanation
```
0g               Input = 0, Output = [0]
  |              Or
   g{   }ᵃ¹⁰     Accumulate 10 times, starting with [Input]
     t+₉         Take the last element, add 9
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~31~~ 27 bytes
```
seq $1 9 $(($1?99:0))|xargs
```
[Try it online!](https://tio.run/nexus/bash#@1@cWqigYqhgqaCioaFiaG9paWWgqVlTkViUXvz//38jAA "Bash – TIO Nexus")
previous
```
eval echo {$1..$(($1?99:0))..9}
```
[Answer]
# Dyalog APL, 15 bytes
```
{(×⍵)/+\⍵,10⍴9}
```
**How?**
`⍵,10⍴9` - concatenate input with 10 `9`s (`⍵ 9 9 9 9 9 9 9 9 9 9`).
`+\` - cumulative sum.
`(×⍵)/` - expand signum times - where signum gives 1 for 1-9 and 0 for 0.
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhGqNw9Mf9W7V1NeOAVI6hgaPerdY1v7//6h3VdqhFQY6j3o3WwIA "APL (Dyalog Classic) – Try It Online")
### Dyalog APL, 24 bytes
```
{⍵/⍨⎕=(⍵≠0)×1+9|⍵-1}⍳100
```
Requires `⎕IO←0`.
**How?**
```
                      ⍳100  ⍝ 0 .. 99
              1+9|⍵-1      ⍝ digit sum (⍵-1 mod 9 + 1)
        (⍵≠0)×             ⍝ edge case for 0
     ⎕=                    ⍝ equals to the input
 ⍵/⍨                       ⍝ compress with the range
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 48 bytes
```
{<>((()()()()()){}){(({}[()])<>[][()]({}))<>}}<>
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/v9rGTkNDQxMGNatrNas1NKprozU0YzVt7KJjQQwgXxPIqa21sfv/3xAA "Brain-Flak – Try It Online")
I may add an explanation later. 
[Answer]
# Mathematica, 25 bytes
```
If[#==0,0,Range[#,99,9]]&
```
works for 0
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
⁵²Ḷµ,³%9EµÐf
```
[Try it online!](https://tio.run/##ASAA3/9qZWxsef//4oG1wrLhuLbCtSzCsyU5RcK1w5Bm////MQ)
**How It Works**
```
⁵²Ḷµ,³%9EµÐf
⁵             - literal 10
 ²            - square
  R           - lowered range: 0 to 99 inclusive.
   µ     µÐf  - filter based on:
    ,³          - element and input
      %9        - mod 9
        E       - are equal
```
[Answer]
# [Actually](https://github.com/Mego/Seriously), 18 bytes
```
╗2╤DR⌠╜-9@%Y⌡░╜;)I
```
[Try it online!](https://tio.run/##S0wuKU3Myan8///R1OlGj6YucQl61LPg0dQ5upYOqpGPehY@mjYRyLPW9Pz/3wAA "Actually – Try It Online")
Explanation:
```
╗2╤DR⌠╜-9@%Y⌡░╜;)I
╗                   save input to register 0
 2╤DR               range(1, 100)
     ⌠╜-9@%Y⌡░      elements in range where function returns truthy:
      ╜-              subtract from input
        9@%           mod 9
           Y          is equal to 0
              ╜;)   push a copy of the input on the top and the bottom of the stack
                 I  if input is truthy, return the filtered range, else return the input (special-cases 0)
```
[Answer]
# PHP, 41 Bytes
prints underscore separated values
```
for(;100>$a=&$argn;$a+=$a?9:ERA)echo$a._;
```
`ERA` is the shortest constant in PHP with the value `131116`. You can replace it with the boring alternative `100` or end the program with `die`
[Online Version](http://sandbox.onlinephpfunctions.com/code/d0d7142b549fbc396e867eba18a644213aa17928)
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), ~~54~~ 52 bytes
```
{<>((((()()())){}{})()){({}<(({})<>({}))><>[()])}}<>
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v@/2sZOAwQ0QVBTs7q2uhbEqNaorrXRABKaQHkgqWlnYxetoRmrWVtrY/f//38TAA "Brain-Flak (BrainHack) – Try It Online")
My first foray with Brain-Flak, and I think I've done pretty well. Anyone with more experience have advice?
### How It Works:
```
{ Don't do anything if input is 0
  <>((((()()())){}{})()) Switch to other stack and add 9 and 10
                         10 is the counter, 9 is to add to the current num
  { While counter
     (
       {} Pop the counter
       <(({})<>({}))> Get a copy of the 9, switch to the other stack and add it to a copy of the top of it. Use <...> to make it return 0
       <>[()] Switch to the other stack and decrement the counter
     ) 
  }
}<> Switch to the stack with the values on it
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
ȷ2ḶDS$ÐL⁼¥Ðf
```
[Try it online!](https://tio.run/##AR8A4P9qZWxsef//yLcy4bi2RFMkw5BM4oG8wqXDkGb///85 "Jelly – Try It Online")
[Answer]
# PHP, 35
```
print_r(range($argn,!!$argn*99,9));
```
Creates the range `[$argn, 100)` with a step of `9` as array and prints it. If the input is `0` it creates the range `[0,0]` => `array(0)`.
[Answer]
# Python, ~~48~~ 51 bytes
*3 bytes saved thanks to @WheatWizard*
```
lambda n:[x for x in range(100)if~-n==~-x%9or x==n]
```
[Answer]
# [R](https://www.r-project.org/), 23 bytes
```
pryr::f(x+0:(10*!!x)*9)
```
[Try it online!](https://tio.run/##K/qfZqP7P600L7kkMz9Po0KzQtvASsPQQEtRsUJTy/J/moaBJleahiGIMAIRxiDCBESYgggzEGEOIixAhKXmfwA "R – Try It Online")
The TIO link uses `function(x)` instead of `pryr::f`, since TIO doesn't have the `pryr` package installed.
[Answer]
## Pyke, 6 bytes (old version)
[Working commit](https://github.com/muddyfish/PYKE/tree/d8ecd04b7b643e54f5d31de3fb962213a1f3f2b1)
```
TXU#sq
```
Explanation:
```
TX     -   10**2
  U    -  range(^)
   #   - filter(^)
    s  -   digital_root(^)
     q -  ^==input
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 25 bytes
```
->a{[*a.step(99,9)]*a|[]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6xOlorUa@4JLVAw9JSx1IzViuxJjq29r@GgZ6epaZebmJBdU1FDVeBQnSFjkJadEVsLFftf0MA "Ruby – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 55 bytes
`f()` need not actually be called with any argument; the `n` is just there instead of outside the function to save a byte.
```
f(n){for(scanf("%d",&n);n&&n<100;n+=9)printf("%d ",n);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI0@zOi2/SKM4OTEvTUNJNUVJRy1P0zpPTS3PxtDAwDpP29ZSs6AoM68ELKugpAOUrf0P5CvkJmbmaWhyVXNxpmloWnPV/jcHAA "C (gcc) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~14~~ 11 bytes
```
Ｉ∧Ｎ⁺Ｉθ×⁹…¹¹
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwzEvRcMzr6C0xK80Nym1SENTRyEgp7QYIlkI5IVk5qYWa1jqKAQl5qWnahgaakKA9f//hv91y3IA "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved ~~2 bytes by not printing anything for zero input and 1 byte by using vectorising operations~~ 3 bytes thanks to @ASCII-only. Explanation:
```
         ¹¹ Literal 11
        …   Range
       ⁹    Literal 9
      ×     Vector multiply
     θ      (First) input
    Ｉ       Cast to number
   ⁺        Vector add
  Ｎ         Input digit as a number
 ∧          Logical AND
Ｉ           Cast to string
            Implicitly print on separate lines
```
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), 11 bytes
```
?56+ř⁻9*+:;
```
[Try it online!](https://tio.run/##K6gs@f/f3tRM@@jMR427LbW0raz//7cAAA "Pyt – Try It Online")
```
?               implicit input; if input is truthy:
 56+            push 11
    ř⁻          řangify; decrement
      9*        multiply by 9
        +       add input
         :;     otherwise, do nothing; implicit print
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `H`, 6 bytes
```
ʁ'∑∑?=
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJIIiwiIiwiyoEn4oiR4oiRPz0iLCIiLCIxIl0=)
Port of kalsowerus's 05AB1E answer.
A port of Kip the Malamute's Pyt answer would be **8 bytes**:
```
:[11ʁ9*+
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCI6WzExyoE5KisiLCIiLCI1Il0=)
#### Explanation
```
ʁ'∑∑?=  # H flag pushes 100
ʁ'      # Filter range(100) by:
  ∑∑    #  Digit sum twice
    ?=  #  Equals the input
```
```
:[11ʁ9*+  # Implicit input
:         # Duplicate
 [        # If input is not 0:
  11ʁ     #  Push range(11)
     9*   #  Multiply by 9
       +  #  Add to input
          # (Otherwise, do nothing)
```
[Answer]
# [Julia 0.6](http://julialang.org/), 18 bytes
I use a ternary to catch the `0` case, and a range `n:9:99` to create the numbers. In julia a range is an `AbstractVector` and can be used in place of an actual `Vector` of numbers in most cases, but it will just print as `1:9:91` which doesn't satisfy the challenge, so I wrap it in `[_;]` to collect the contents into a `Vector`.
```
n->n>0?[n:9:99;]:0
```
[Try it online!](https://tio.run/##yyrNyUw0@5@mYKuQlJqemfc/T9cuz87APjrPytLK0tI61srgf2peCldafpFCJlCRgZUlF6dDcUZ@uUKmTppGpiYXUPY/AA "Julia 0.6 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 25 + 1 (`-n`) = 26 bytes
```
say;!$_||($_+=9)>99||redo
```
[Try it online!](https://tio.run/##K0gtyjH9/784sdJaUSW@pkZDJV7b1lLTztKypqYoNSX//3@jf/kFJZn5ecX/dX1N9QwMDf7r5gEA "Perl 5 – Try It Online")
[Answer]
**Clojure, 33 bytes**
```
(fn[n](if(> n 0)(range n 100 9)))
```
[Answer]
# [Clojure](https://clojure.org/), 38 bytes
```
(defn f[n](if(pos? n)(range n 100 9)))
```
or as anonymous function which is 29 bytes
```
(#(if(pos? %)(range % 100 9))n)
```
[Try it online!](https://tio.run/##S87JzyotSv3/XyMlNS1PIS06L1ZBIzNNoyC/2F4hT1OjKDEvPVUhT8HSUsFSU1Pzv0ZBUZ5GmoIpkAkA "Clojure – Try It Online")
thanks @steadybox 
]