[Question]
  [
A [self number](https://en.wikipedia.org/wiki/Self_number) (also called a Colombian or Devlali number) is a natural number, `x`, where the equation `n + <digit sum of n> = x` has no solutions for any natural number `n`. For example, **21** is not a self number, as `n = 15` results in `15 + 1 + 5 = 21`. On the other hand, **20** *is* a self number, as no `n` can be found which satisfies such an equality.
As this definition references the digit sum, it is base dependent. For the purposes of this challenge, we will only be considering base 10 self numbers, which are sequence [A003052](https://oeis.org/A003052) in the OEIS. Binary ([A010061](https://oeis.org/A010061)) and base 100 ([A283002](https://oeis.org/A283002)) self numbers have also been calalogued.
## The Challenge
Given a positive integer `x` as input, output a truthy value if `x` is a self number in base 10, and a falsey value otherwise. For clarification of truthy and falsey values, refer to [this meta post on the subject](https://codegolf.meta.stackexchange.com/a/2194/41020).
You may write a full program or function, and input and output may be provided on any of the usual channels. [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are, of course, banned.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shorter your answer (in bytes) the better!
## Test cases
Truthy:
```
1
3
5
7
9
20
31
86
154
525
```
Falsey:
```
2
4
6
8
10
15
21
50
100
500
```
[Sandbox link](https://codegolf.meta.stackexchange.com/a/16052/41020)
## Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
# Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
var QUESTION_ID=159881,OVERRIDE_USER=41020;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 37 bytes
```
@(n)sum(dec2base(t=1:n,10)'-48,1)+t-n
```
Port of my MATL answer.
[Try it online!](https://tio.run/##TY1BCoMwFET3nmJ2RqohPxqbFoTeo3RhNaGCxmJioadPU@iii2GG9xazDqF/mWg7znm8MFf4fWGjGeS994aFjs6uJFHkVaNLKg6hctGuGxw6XAk1FI44QQrUBN2CVAMlFSQatNAgkRAkQaUhRCpxy4DJwqavtIBx8k@Wh20Pj3f@RWb25s/YfvY/4cYsJX4A "Octave – Try It Online")
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 84 bytes
```
i->{for(int n=i;i-->1;)i|=((""+i).chars().map(x->x-48).sum()+i^n)-1>>-1;return~i<0;}
```
[Try it online!](https://tio.run/##PVDLTsMwELz3K1aRKtnUdpPSQiEkdw5ISD0ikEwerUviRPamalXCrwc7hVqyd9cz4531Xh4k3@dfg6rbxiDsXS06VJUoO52harS4iSdZJa2FF6k0nCcAbfdZqQwsSnTh0KgcaoeRDRqlt2/vIM3W0pEK8Kzx1RS5yiQWUEIyKJ6ey8YQpRF0omLFeRrFVH0nhATBTFGR7aSxhIpatuTI0yNfrqmwXU3oTH1oyqM05VFsCuyM/lFPYdwP8djLPem6Y2HRQvLX36@IwS2DFYN7Bg8MFqGr3d36jkG0Wjpk4bD5HNB0uDtdZQsGDnSkteOFnuu0TrfyeRj6JPSyUlb2X9XHkzFzE8I4onfzePFEr5Y2J4tFLZoORev@DEsSTHPgKUztVAdspDMohY/EH5ReJuwnfvfDLw "Java (JDK 10) – Try It Online")
## Explanation
```
i->{                                    // IntPredicate
  for(int n=i;i-->1;)                   //  for each number below n
    i|=(                                //   keep the sign of
      (""+i).chars().map(x->x-48).sum() //    sum of digits
      +i                                //    plus the number
      ^n                                //    xor n (hoping for a zero)
     )-1>>-1;                           //    changing that into a negative number if equals to zero
  return~i<0;                           //  return i>=0
}
```
## Credits
* -1 byte thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
* -1 byte thanks to [Nevay](https://codegolf.stackexchange.com/users/69142/nevay)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
LD€SO+ÊW
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fx@VR05pgf@3DXeH//xuamgAA "05AB1E – Try It Online")
or as a [Test suite](https://tio.run/##MzBNTDJM/V9TVln538flUdOaYH/tw13h/yuVDu9X0LVTOLxfSUcz5r8hlzGXKZc5lyWXkQGXsSGXhRmXoakJl6mRKZcRlwmXGZcFl6EBUIjLyJDLFMgwMABSBgA)
**Explanation**
```
L          # push range [1 ... input]
 D         # duplicate
  €S       # split each number into a list of digits
    O      # sum digit lists
     +     # add (n + digitSum(n))
      Ê    # check for inequality with input
       W   # min
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 12 bytes
```
¬{⟦∋Iẹ+;I+?}
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//9Ca6kfzlz3q6PZ8uGuntrWntn3t//9GBv8B "Brachylog – Try It Online")
### Explanation
```
¬{         }    Fails if succeeds, suceeds if fails:
  ⟦∋I             I ∈ [0, ..., Input]
    Iẹ+           The sum of the elements (i.e. digits) of I...
       ;I+?       ... with I itself results in the Input
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~49~~ ~~47~~ 44 bytes
```
@(x)arrayfun(@(k)k+sum(num2str(k)-48)-x,1:x)
```
[Try it online!](https://tio.run/##JYxBCsIwFET3PcVspAm2wYqCFAo9iJuo@fCpTctPIvH0MeBi4D14zPaM9uMKTcaYMqusrYj9UvJqVotejiGtyqf1HKJU7y833eduGLMutAmYMWEYr6cGYAIpZl0R2IV9JNUeGBxgEdybUH8eTu6@7f6Z86@mrvwA "Octave – Try It Online")
**Explanation:**
Trying to do the operation on a range is cumbersome and long, since `num2str` returns a string with spaces as separators if there are more than input number. Subtracting 48 would therefore give something like: `1 -16 -16 2 -16 -16 3 -16 -16 4` for an input range **1 ... 4**. Getting rid of all the `-16` takes a lot of bytes. 
Therefore, we'll do this with a loop using `arrayfun`. For each of the numbers **k = 1 .. x**, where **x** is the input, we add `k` and its digit sum, and subtract `x`. This will return an array of with the result of that operation for each of the numbers in **k**. If any of the numbers in the array is a zero, the number is not a self number.
For inputs `20` and `21`, the outputs are:
```
20:  -18, -16, -14, -12, -10, -8, -6, -4, -2, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 2
21:  -19, -17, -15, -13, -11, -9, -7, -5, -3, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 1, 3
```
There are only non-zero elements for input `20`, and at least one non-zero element for input `21`. That means that `20` is a self number, and `21` is not.
Octave treats an array with at least one zero as false, as can be seen in the TIO-link.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~70~~ ~~67~~ 65 bytes
```
i,r,d,j;f(n){for(r=i=n;d=j=--i;r*=d!=n)for(;j;j/=10)d+=j%10;i=r;}
```
[Try it online!](https://tio.run/##NY1BbsIwEEXX@BRupEh2sVUnkBZqzbYn6DIbFDepLTpUJiAhlLOnpB6v3mjm/fmdHrpunr2Kyqlge4Hy3p@iiOABrYMAWnsbn8E9AcrlYoMNL1AZ6dYQyspYD9FO8/XkHR@Ex5GjZHe2@o2PuRdFuXG8dC0WiqPiS4G0bGJsMX8OHkWyL@NZFJ/xMn7f3lvUWhcPbTWIKmGT0CS8JewTakMOubtXijZbStX/udzS4sfheP6inlxUJ1CEXuzok8kfyaWmJu@NyYtlmOY/ "C (gcc) – Try It Online")
To shave off another 2 bytes, the truthy value returned is no longer 1, but the number itself.
[Answer]
# [J](http://jsoftware.com/), 28, 24, 22 21 bytes
-1 byte thanks to Conor O'Brien
-2 byts thanks to ngn
```
$@-.(+1#.,.&.":)"+@i.
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/VRx09TS0DZX1dPTU9JSsNJW0HTL1/mtycaUmZ@QrpCkYwhjGMIYpjGEOY1jCGEYGcNVwfRZmcKNMTeBmGJnCbTCCMeCycB0WcK0GCEPg@uBWmCJkDQwQggb/AQ "J – Try It Online")
## Explanation:
`i.` a list 0 .. n-1
`( )"+` for each item in the list
`.,.&.":` convert it to a list of digits,
`1#` find their sum
`+` and add it to the item
`$@-.` exclude the list from the argument and find the shape 
[Answer]
# [MATL](https://github.com/lmendo/MATL), 11 bytes
```
t:tFYA!Xs+-
```
The output is a non-empty array, which is truthy if all its entries are non-zero, and falsy if it contains one or more zeros.
[Try it online!](https://tio.run/##y00syfn/v8SqxC3SUTGiWFv3/39DUwA "MATL – Try It Online") Or [verify all test cases](https://tio.run/##bc69CsIwFAXg/TxFHKSDWJK0qdVFhCq4OTjoIFhoawMxLU2KdPDZYzsoGbzL/eGDe565Ve5OvjUnWROG4auWqnR2Yw/X3exiFku39cixQmC73tZDMK2n3tTE1tIQYzupH3h7dq9MSQiCKldm4v/8zfe6QObHkaZV@YCz/19XUktbkuKXlaimaR1DBIEV1uAUEUOagIkYggtwxEiQgtHxBM4gxoHSsdEP), including truthiness/falsihood test.
### Explanation
Consider input `n = 10` as an example.
```
t       % Implicit input, n. Duplicate
        % STACK: 10, 10
:       % Range
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10]
t       % Duplicate
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 10]
FYA!    % Convert to base 10 digits and transpose
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [0 0 0 0 0 0 0 0 0 1
                                              1 2 3 4 5 6 7 8 9 0]
Xs      % Sum of each column
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 1]
+       % Add, element-wise
        % STACK: 10, [2 4 6 8 10 12 14 16 18 11]
-       % Subtract, element-wise
        % STACK: [8 6 4 2 0 -2 -4 -6 -8 -1]
        % Implicit display
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 14 bytes
```
~⊢∊⍳+(+/⍎¨∘⍕)¨∘⍳
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24S6R12LHnV0PerdrK2hrf@ot@/QikcdMx71TtWEMjb//29Q96h3hQaQaWKgeXh6GlACxAQA "APL (Dyalog Unicode) – Try It Online")
**How?**
```
               ⍳   range
     (  ⍎¨∘⍕)      digits
     (+/    )      digit sums
   ⍳+              vectorized addition with the range
 ⊢∊                is the input included?
~                  negate
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
ḟDS+Ɗ€
```
For input **n**, this returns **[n]** if **n** is a self number, **[]** if not.
[Try it online!](https://tio.run/##y0rNyan8///hjvkuwdrHuh41rfl/uB1IRv7/b6ijYKyjYKqjYK6jYKmjYGQA5APFLMx0FAxNTYAyRkA5Ix0FIBMoZAEUNQDJAMWAqkxBbAMDEMMAAA "Jelly – Try It Online")
### How it works
```
ḟDS+Ɗ€  Main link. Argument: n
     €  Call the link to the left for each k in [1, ..., n].
    Ɗ     Drei; combine the three links to the left into a monadic chain.
 D          Decimal; map k to the array of its digits in base 10.
  S         Take the sum.
   +        Add k to the sum of the k's digits.
ḟ       Filterfalse; promote n to [n], then remove all elements that appear in the
        array to the right.
        This returns [n] if the array doesn't contain n, [] if it does.
```
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 32 bytes
```
n->!sum(i=1,n,i+sumdigits(i)==n)
```
[Try it online!](https://tio.run/##FcjLCoMwEIXhV0ldZegJZKLxsogvUroQijLQDkHtok8f09X5zp@XXdyWy2pSUTffju/HSmIo5F79kk3OwwqlpFSWnN8/q8bNJu@iZ2XzP41ZrRLBPBgtIgZMCB4tY@zBsUMMEQEdeoxgXxMCI1Z4X8c/qVw "Pari/GP – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 46 bytes
```
f x=and[x/=n+sum[read[d]|d<-show n]|n<-[1..x]]
```
[Try it online!](https://tio.run/##bY6xboNADIb3PsUf1CERDuVISNMqDB3SqZ2aDaHqyBkRFQ56d6gMeXcKiZQu9eJftj5/LqX94qoahgJ9IrVK@4dE@7arU8NSpSo7q93Sls0PdHbWu2UqgqDPsqGWJ40EqrnDWBU7SGvZuP03JPJxcyogkySHK1nDsOuMni/AlWWwMY3BPbz9FGbY9y0fHatneL5/cUnf9/BydJ2s/ob5RVXL9v0T85vtYDpGgGKBVNCKYnqkJ4pCWgnabkjEa4qjOPsXfZXTN1c2ojVtaEsiHBmKBMVjCMOxhVe47dyHM28a3oGts2inM2rmDb8 "Haskell – Try It Online")
[Answer]
# Scala, ~~44~~ 42 bytes
```
x=>0 to x forall(n=>x!=(n/:s"$n")(_+_-48))
```
[Try it online](https://scastie.scala-lang.org/O9mJjklnT3ODlUIPhYgM7w)
[Answer]
# [Perl 5](https://www.perl.org/) `-a`, 34 bytes
```
#!/usr/bin/perl -a
say!grep{s/./$_+=$&/reg;/@F/}1..$_
```
[Try it online!](https://tio.run/##FcqxCsIwFAXQ/f6FEFykSW7aNA1FcHLzG0qHUASxIeki4q/3qWc@OZWHF6nz67CUlN/VaKOm01kdTUnLaC5X86HWahIhHFp08OgRMCCCFiTowBbsQA/2YAAHMMJZOCIGxN/9Z4t9zdt9fVZpZmluXtNq@wU "Perl 5 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 38 bytes
```
->x{(1..x).all?{|n|n+n.digits.sum!=x}}
```
[Try it online!](https://tio.run/##DchLDsIgFEbhuavQmcbfGy4ttQ7QhTQd1Ee1SSVGIMEAa8eOzpfz9ddfGXU5nEPcMlHY0TDPl5hMMntD9@k5OUvWvzc65Fyc7hgVFI44QQpUjLYBqxpKKkjUaNCCxbIgGWqBEEtEv3L0GG6vmEL6eGfXYxf6XP4 "Ruby – Try It Online")
[Answer]
# Python 2, ~~70~~ 66 Bytes
```
lambda x:[i for i in range(x)if i+sum([int(j)for j in`i`])==x]==[]
```
EDIT: -4 thanks to @user56656
[Answer]
# [Pyth](https://pyth.readthedocs.io), 8 bytes
```
!/m+sjdT
```
[Test suite.](https://pyth.herokuapp.com/?code=%21%2Fm%2BsjdT&input=154&test_suite=1&test_suite_input=1%0A3%0A5%0A7%0A9%0A20%0A31%0A86%0A154%0A525%0A2%0A4%0A6%0A8%0A10%0A15%0A21%0A50%0A100%0A500&debug=0)
If swapping truthy / falsy values is allowed, then we can drop the `!` and get 7 bytes instead. One of [Sok](https://codegolf.stackexchange.com/users/41020/sok)'s suggestions helped me golf 2 bytes.
## Explanation
```
!/m+sjdT – Full program. Takes an input Q from STDIN, outputs either True or False.
  m      – Map over the range [0 ... Q) with a variable d.
     jdT – Convert d to base 10.
    s    – Sum.
   +     – And add the sum to d itself.
 /       – Count the occurrences of Q in the result.
!        – Negate. Implicitly output the result.
```
[Answer]
# [Perl 6](https://perl6.org/), ~~39~~ 33 bytes
```
{!grep $_,map {$_+[+] .comb},^$_}
```
[Try it out!](https://tio.run/##K0gtyjH7n1upoJamYPu/WjG9KLVAQSVeJzexQKFaJV47WjtWQS85PzepVidOJb72f3FipUKahqGCgqY1F4RtjMQ2RWKbI7EtkdhGBkh6DRFsCzME29DUBGGmkSlCL5I5JkhsMyS2BRLb0ADZTCQ3INlriqzGwABJHMj@DwA)
A bare block with implicit single parameter, called thus:
```
say {!grep $_,map {$_+[+] .comb},^$_}(500);
> False
say {!grep $_,map {$_+[+] .comb},^$_}(525);
> True
```
Since `n + digits(n) >= n`, we can just calculate the Colombian number for all the numbers up to our query value and see if any of them match. So this calculates the Colombian number for a given input:
```
{$_ + [+] .comb}
```
Which we apply to all the values up to our target:
```
(^$_).map({$_+[+] .comb})
```
But we only care whether any of them match, not what those values are, so as pointed out by @nwellenhof, we can grep:
```
grep $_, map {$_+[+] .comb}, ^$_
```
The rest is just coercion to bool and wrapping in a block.
## 39 bytes
```
{!((^$_).map({$_+[+] .comb}).any==$_)}
```
[TIO test link provided by @Emigna](https://tio.run/##Tc5NCoMwEAXgvacYQUqCEBJrUkVyEmklLboyrdRVEM8eBRd5u4/5eTPL@J9N9IFuE9m45Yy9ioEL7xa2FUPZl08Sn59/71y4b7D2bO5xdYEmpoh4l12@gzX4AW7BlYRdldyYZKXrlFnptAs5NdiAG7CSmAk/wF2NM1JC/XQ8AA)
@nwellenhof pointed out that using grep would save 6 bytes!
[Answer]
# [Python 3](https://docs.python.org/3/), 60, 56, 55, 54 bytes
```
lambda x:{x}-{n+sum(map(int,str(n)))for n in range(x)}
```
[Try it online!](https://tio.run/##Lc3RCoIwGAXg@55iN@I/OoGbTU3oSaqLiVkD3WQaGOKzrwmdmwMfB874nd/O5qG73kOvh6bVbKnXZTut9jh9Bhr0SMbOmGZPlnPeOc8sM5Z5bV9PWvgWdjI73QQkcpyhUKBEhQtEBqEgM0iBXKAqouwUN7GVVI/6wP4ZfTyiNGnrZEoTMmic66kjE295@AE "Python 3 – Try It Online")
-4 using all inverse instead of any  
-1 by changing != to ^ by @jonathan-allan  
-1 by using sets by @ovs
[Answer]
# [J](http://jsoftware.com/), 20 bytes
```
#@-.i.+1#.10#.inv i.
```
[Try it online!](https://tio.run/##RY0xDoAwDAP3viJSR0SUFgplQOIviIoywMb3w0Lc7RT7nEu1rEx@67lyFzwH8VzvlyrrsZ8PFQruh8EgGcwGi0EUtOHlySikERsxOUgGSGFkqNJG4OFFaqlIO4p@ "J – Try It Online")
```
                  i.     Range [0,n-1]
          10#.inv        To base 10
       1#.               Sum the digits
    i.+                  Plus the corresponding number
  -.                     Remove from the input, leaves an empty list if it was a self number.
#@                       An empty list is truthy, so return the length instead.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-d!`](https://codegolf.meta.stackexchange.com/a/14339/), 6 bytes
```
N¥U+ìx
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWQh&code=TqVVK%2bx4&input=MjE)
---
## Original, 8 bytes
Returns the input number for truthy or `0` for falsey. If only the empty array were falsey in JavaScript, this could be 7 bytes.
```
ÂNkUÇ+ìx
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=wk5rVccr7Hg=&input=ODg=)
---
### Explanation
```
             :Implicit input of integer U
   UÇ        :Generate the range [0,U) and pass each Z through a function
      ì      :  Digits of Z
       x     :  Reduce by addition
     +       :  Add to Z
  k          :Remove the elements in that array
 N           :From the array of inputs
Â            :Bitwise NOT NOT (~~), casts an empty array to 0 or a single element array to an integer 
```
---
### Alternative
```
Ç+ìxÃe¦U
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=xyvseMNlplU=&input=ODg=)
```
             :Implicit input of integer U
Ç            :Generate the range [0,U) and pass each Z through a function
  ì          :  Digits of Z
   x         :  Reduce by addition
 +           :  Add to Z
    Ã        :End function
     e       :Every
      ¦U     :  Does not equal U
```
[Answer]
# [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), ~~27~~ 18 bytes
```
L,RFBDB+B]ARz€b+Ae
```
[Try it online!](https://tio.run/##S0xJKSj4/99HJ8jNycVJ2ynWMajqUdOaJG3H1P8lVtGGCsYKpgrmCpYKRgYKxoYKFmYKhqYmCqZGprFcaVbRRgomCmYKFgqGBkBhBSNDBVMgw8AASBnEcnG5luhwcaZkggglXTslIK2Sk5iblJKoYGgHEvXn4vJXUgKqSyOg7r@RAQA "Add++ – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-apl -MList::Util=sum,all`, 28 bytes
```
$_=all{"@F"-sum/./g,$_}1..$_
```
[Try it online!](https://tio.run/##Fc27CsIwAAXQ/X5G6dikuekjTaHg5KSjc@ggEog2mDiJv26s@4ETr88wlFK7ZQ3hXR2OlUiveyvbW1O7D6WsXSmERoceA0YYTLCgAglqsAN7cABH0IATaKEVNGEN7G7/WOG7xey3RyrifPIpz/Ml@7DsVbO/Rawx/AA "Perl 5 – Try It Online")
[Answer]
# [Lua](https://www.lua.org/), 81 bytes
```
for i=1,...do a=i+0(i..''):gsub('.',load'a=a+...')b=b or a==0+...end print(not b)
```
[Try it online!](https://tio.run/##FctBCoAgEEDRq8xuFGWwwE0whxmxQhANs/NPtf28Xx9RPfqAwosnotxBuLhgChGi3c77SQYJfe2SUVjch9AmTvBNwhz@sLcM1yhtmtYnJKuqcY0v "Lua – Try It Online")
```
for i=1,...do
    a=i+0                            -- +0 is needed to avoid an error
    (i..''):gsub('.',load'a=a+...')  -- Sums up all the digits of i
    b=b or a==0+...                  -- Sets b to true if a equals the input
end 
print(not b)
```
[Answer]
# [FunStack](https://github.com/dloscutoff/funstack) alpha, 46 bytes
```
All? Minus Plus foldl ToBase 10 hook map From0
```
Try it at [Replit](https://replit.com/@dloscutoff/funstack)!
### Explanation
First, we construct a function that adds a number to its base-10 digit sum:
```
Plus foldl                 Left-fold second argument on addition, with first
                           argument as starting value
                     hook  Take a single argument; pass it to the above function
                           twice: first, unchanged, and second, passed through
                           the following function:
           ToBase 10       Convert to list of base-10 digits
```
This is a bit shorter than the alternatives:
```
Plus Sum ToBase 10 over hook
Sum Pair ToBase 10 compose3
```
Then:
```
                   From0  Range of integers from 0 up to input-1
           ... map        Map the above function to each
     Minus                Subtract each from the input
All?                      Are all results truthy (non-zero)?
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), ~~18~~ 12 bytes
```
aNI:_+$+_M,a
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724ILNgUXTsgqWlJWm6FmsS_Tyt4rVVtON9dRIhQlCZJdFGBjBVAA)
*-6 thanks to @DLosc*
#### Explanation
```
aNI:_+$+_M,a  ; Full program. Input (a) on command line
         M,a  ; Map over the range from 0 to a (_)
      $+_     ;  Sum _
    _+        ;  And add this to _
aNI:          ; Is a not in this list?
              ; Implicit output
```
Old:
```
$*Y{\a!=a+$+a}M\,a  ; Full program. Input (n) on command line.
               \,a  ; Range from 1 to n
   {         }M     ; Map over this list (a):
          $+a       ;  Sum the digits of a
        a+          ;  Add to a
    \a!=            ;  And check if it's not equal to n
$*Y                 ; Get the product of this list
                    ; Implicit output
```
[Answer]
# [Arturo](https://arturo-lang.io), ~~36~~ 34 bytes
```
$->x[every? x'n->x<>+∑digits<=n]
```
[Try it](http://arturo-lang.io/playground?F6U5Kl)
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 55 bytes
```
.+
*
Lv`_+
_+
$&$.&
^_+
$&¶$&
\d
*
Cms`^(_+)\b.*¶\1\b
0
```
[Try it online!](https://tio.run/##HYlBDoIwFAX3c47aIE2a/wtFXLtw4xEaQKILF7hQ49E4ABerjckkb/Lmdf88nlfNu@o8Ze@ouXyn0VEw1njL8LdtNZZ0K/m0vKehGt0@zb7e1qRpRnJWGiIHjgShUfoOjS0xRAItHT0q5SIosYhIGfkB "Retina – Try It Online") Link includes test cases. Explanation:
```
.+
*
```
Convert input `x` to unary.
```
Lv`_+
```
Create a range from `x` down to `1`.
```
_+
$&$.&
```
Suffix the decimal value of each `n` to its unary value.
```
^_+
$&¶$&
```
Make a copy of `x`.
```
\d
*
```
Convert each decimal digit of `n` to unary, thus adding the digits to the existing copy of `n`.
```
Cms`^(_+)\b.*¶\1\b
```
Check whether `x` appears in any of the results.
```
0
```
Invert the result.
[Answer]
# JavaScript (ES6), ~~52~~ 51 bytes
*Saved 1 byte thanks to @l4m2*
Returns **0** or **1**.
```
n=>(g=k=>k?eval([...k+'k'].join`+`)-n&&g(k-1):1)(n)
```
[Try it online!](https://tio.run/##bctBDoMgEEDRfU/hSiCOBFCsbYI9iDGRWCWKHUxtvD5126Sr/zdvsYfdh/e8fXIMzzFOJqJpqDPeNP4xHnalLefcZ8STji9hxj7rWY5p6qjPJbtLRpHFIeAe1pGvwdFWQgEarnADJaCQUFcgdQla6Y6/7EYxMU0yUcwIYYxdfqyCEiqoQYrTgJKgzxHijPiH4xc "JavaScript (Node.js) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~63~~ 58 bytes
```
s 0=0
s x=x`mod`10+s(x`div`10)
f n=all(\x->x+s x/=n)[1..n]
```
[Try it online!](https://tio.run/##dZAxb8IwEIV3/4rXqAMIldopoTC4Q4cuoDK0G63kSHGUCONUOEHm1wcPDEjVu8n6Pt/d0zVlOFjnxjFAaikCoo7m2FVGyVmYRFO15/Scihpel85NfuLTW5ylb8/aT/dqPve/Y4QJTTe46t0aXKDxN/Rf/Wnr8Yi2RoTWCfeN9ch2mwzWBYvss@ux2zxkQhzL1qeuqhNIVUPdz/s@DfbGXwgvCH8lfE14Ltlilmi1JEIVCxY2Z3Hze/5RpiPdxIKJJRMrJpSkpmAmV8wUfJqUvOm/Gq8 "Haskell – Try It Online")
]