"Digitale Summe" bezieht sich auf die Summe aller Ziffern einer Zahl.

Zum Beispiel kann die digitale Summe 1324ist 10, da 1+3+2+4 = 10.

Die Herausforderung besteht darin, ein Programm / eine Funktion zu schreiben, um die kleinste Zahl zu berechnen, die größer ist als der Eingang, dessen digitale Summe der Eingang ist.

Beispiel mit exemplarischer Vorgehensweise

Nehmen Sie 9als Beispiel die Nummer als Eingabe:

9 = 1+8 -> 18
9 = 2+7 -> 27
9 = 3+6 -> 36
...
9 = 8+1 -> 81
9 = 9+0 -> 90

Die gültige Ausgabe wäre die kleinste Zahl darüber 18.

Technische Daten

Beachten Sie, dass dies 9nicht die gültige Ausgabe für dieses Beispiel ist, da die umgekehrte Zahl größer sein muss als die ursprüngliche Zahl.

Beachten Sie, dass der Eingang positiv ist.

Testfälle:

 2 => 11      (2 = 1 + 1)
 8 => 17      (8 = 1 + 7)
12 => 39     (12 = 3 + 9)
16 => 79     (16 = 7 + 9)
18 => 99     (18 = 9 + 9)
24 => 699    (24 = 6 + 9 + 9)
32 => 5999   (32 = 5 + 9 + 9 + 9)

Verweise:

Dies ist OEIS A161561 .

Bearbeiten: Zusätzlicher Testfall hinzugefügt (18)

Vielen Dank an Martin Ender für das Leaderboard Snippet

var QUESTION_ID=81047,OVERRIDE_USER=31373;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>

05AB1E, 19 17 8 Bytes

Code:

[>DSO¹Q#

Erklärt:

[            # start infinite loop
 >           # increase loop variable, will initially be input
  DSO        # make a copy and sum the digits
     ¹Q#     # if it equals the input, break
             # else return to start of loop
             # implicitly print

Probieren Sie es online aus

Bearbeiten: 9 Bytes dank @Adnan gespeichert

Python 2, 33 Bytes

lambda n:[n+9,`n%9`+n/9*'9'][n>9]

Ein direkter Ausdruck. Erstellt eine Zahlenfolge mit 9 am Ende und dem Rest am Anfang. Ausgenommen, für einstellige ngibt n+9.

Einige Ausgänge haben führende Nullen ( 099für 18).

Retina , 39 31 Bytes

r`1{1,9}
$.&
T`d`_d`^.$
^.$
1$&

Nimmt unäre Eingaben auf .

Probieren Sie es online! (In den ersten beiden Zeilen können mehrere Testfälle gleichzeitig ausgeführt und aus Bequemlichkeitsgründen von dezimal nach unär konvertiert werden.)

Dies sucht nicht linear nach dem Ergebnis, sondern berechnet es explizit:

• Wenn die Eingabe ngrößer als 9 ist, ersetzen wir sie n % 9durch n / 9(mit Fußboden versehene) Neunen.
• Ansonsten ersetzen wir es durch n + 9.

Wenn ich !(oder irgendetwas anderes, was nicht 1der Fall ist ) als unäre Ziffer verwende, kann ich mit dem folgenden Ansatz ein weiteres Byte speichern:

^!(?!!{9})
1
r`!{0,9}
$.&
0\B

Aber dieses Eingabeformat ist meiner Meinung nach ein bisschen langwierig.

Pyth , 8 Bytes

fqQsjT;h

Testsuite.

fqQsjT;h

f      h first number T from (input+1) onward where:
 qQ          the input is equal to
   s         the sum of
    jT;      the base-10 representation of T

Java 7, 68 61 Bytes

int f(int n){return n>9?-~(n%9)*(int)Math.pow(10,n/9)-1:n+9;}

Macht ungefähr das Gleiche wie viele der anderen Antworten hier. Wollte den Java-Ansatz ohne String-Manipulation und Schleifen zeigen.

Danke an FryAmTheEggman, der mich daran erinnert hat, dass ich dumm bin;)

MATL , 10 9 Bytes

`QtV!UsG-

Probieren Sie es online!

Erläuterung

`        % Do...while
  Q      %   Add 1. Takes input implicitly the first time
  t      %   Duplicate
  V!Us   %   To string, transpose, to number, sum. Gives sum of digits
  G-     %   Subtract input. If 0, the loop ends and the stack is implicitly displayed

JavaScript (ES7), 32 Byte

n=>(n%9+1)*10**(n/9|0)-(n>9||-8)

38 Bytes als ES6:

n=>parseFloat(n%9+1+'e'+n/9)-(n>9||-8)

Python 3, 128 94 84 74 Bytes

Ohne Ausgabe, Direktansprache, Anfänger Codegolfer;)

def r(n):
 m=n
 while 1:
  m+=1
  if sum(map(int,str(m)))==n:return(m)

Eigentlich 17 Bytes

╗1`;$♂≈Σ╜;)=)>*`╓

Probieren Sie es online!

Erläuterung:

╗1`;$♂≈Σ╜;)=)>*`╓
╗                  save input to reg0
 1`;$♂≈Σ╜;)=)>*`╓  first integer n (>= 0) where:
   ;$♂≈Σ╜;)=         the base-10 digital sum equals the input and
            )>*      is greater than the input

C 73 65 Bytes

Ein Makro mit einer Hilfsfunktion.

e(y){return y?10*e(y-1):1;}
#define F(n) n<9?n+9:(1+n%9)*e(n/9)-1

Die eFunktion berechnet nur Zehnerpotenzen, und das FMakro verwendet dieselbe Lösungsmethode wie dieser Ruby und diese Python- Antwort. Leider ist es länger als ungefähr so ​​lang wie die beiden Antworten zusammen. Aber es ist die erste Antwort von C.

(8 Bytes durch Lynns Trick des Entfernens gespart int.)

Brachylog , 8 Bytes (nicht konkurrierend)

<.=:ef+?

= wurde nach dem Posten dieser Challenge modifiziert, so dass es nun auf möglicherweise unendlichen Domains funktioniert, was hier der Fall ist.

Erläuterung

<.       Output > Input
  =      Label the Output (i.e. unify it with an integer)
   :ef   Get the list of digits of the Output
      +? Input is the sum of all those digits

Dies wird solange zurückverfolgt, =bis der Wert von Output dieses ganze Prädikat als wahr ansetzt.

TSQL (SQL Server 2012), 107 bis 99 Byte

DECLARE @ INT = 32

,@2 char(99)WHILE @>0SELECT
@2=concat(x,@2),@-=x FROM(SELECT IIF(@>9,9,IIF(@2>0,@,@-1))x)y PRINT @2

Probieren Sie es online!

Python 2, 39 Bytes

lambda n:[n+9,(1+n%9)*10**(n/9)-1][n>9]

Reine Ganzzahlarithmetik.

Volles Programm mit Ausgabe

f=lambda n:[n+9,(1+n%9)*10**(n/9)-1][n>9]

print(f(2))
print(f(8))
print(f(12))
print(f(16))
print(f(17))
print(f(18))
print(f(24))
print(f(32))

Ausgabe:

11
17
39
79
89
99
699
5999

PowerShell v2 +, 62 Byte

param($n)for($a=$n+1;([char[]]"$a"-join'+'|iex)-ne$n;$a++){}$a

Übernimmt die Eingabe $nund führt dann eine forSchleife aus. Wir initialisieren die Schleife, indem wir unsere Zielnummer so einstellen $a, dass sie eine Nummer größer ist als $n(da sie größer sein muss, wird dies auch sichergestellt)1..9 korrekt funktioniert). Jede Schleife wird inkrementiert $a++. In der eigentlichen Schleife passiert nichts, aber die Bedingung ist, wo die Programmlogik passiert. Wir nehmen die Zielnummer buchstäblich als Zeichenkette, wandeln sie in ein Zeichen-Array um, setzen -joindas Array mit +und leiten es dann weiter iex(ähnlich wie eval). Wir testen, ob dies unserer Eingabenummer entspricht oder nicht, und setzen die Schleife entsprechend fort. Sobald wir die Schleife verlassen haben, haben wir erreicht, dass unsere Zielzahl eine Ziffernsumme ist, die unserer eingegebenen Zahl entspricht$a wird in die Pipeline eingefügt und die Ausgabe ist implizit.

Als Referenz sehen Sie hier die Methode "Konstruiere eine Zeichenkette mit der entsprechenden Anzahl von 9", die andere Leute mit 67 Bytes durchgeführt haben

param($n)(($n+9),(+(""+($n%9)+'9'*(($n/9)-replace'\..*'))))[$n-gt9]

oder die "pure integer arithmetic" Methode, die andere Leute gemacht haben, bei 70 Bytes durchgeführt haben

param($n)(($n+9),("(1+$n%9)*1e$(($n/9)-replace'\..*')-1"|iex))[$n-gt9]

Keiner von beiden ist kürzer, aber beide sind interessanter.

Pyke, 9 8 7 Bytes, nicht konkurrierend - verwendet eine neuere Version

.fhsq)h

Probieren Sie es hier aus!

.f      - first where true:
  h     - n+1
   sq    - digital_root(^) == input()
      h - that number +1

JavaScript (ES2015), 45 39 33 Bytes

Weitere 6 Bytes dank @Conor O'Brien und @Shaun H. gespart.
Ich denke, ich lasse es so, wie es ist, da diese Version sich von der Antwort von @ Neil durch die Verwendung von unterscheidet String.repeat().

v=>+(v>9?v%9+'9'.repeat(v/9):v+9)

Vorherige Version (6 Bytes dank @Qwertiy eingespart):

f=v=>+(v/9>1?v%9+'9'.repeat(v/9|0):v+9)

Erste Version:

f=v=>+(v/9>1?v%9+'9'.repeat(~~(v/9)):'1'+v-1)

Lua, 52 Bytes

n=...+0
print(n>9 and(n%9)..string.rep(9,n/9)or n+9)

Soll in einer Datei gespeichert und mit dem Lua-Interpreter ausgeführt werden, z lua <file> <input number>

Sie können es auch hier versuchen: https://repl.it/CXom/1

(Bei Repl.it ist die Eingangsnummer zum leichteren Testen fest codiert.)

Schläger 70 Zeichen, 71 Bytes

Gleicher Algorithmus wie die meisten anderen. Ziemlich traurig darüber, dass ich nicht standardmäßig% für Modulo oder ** für Expt oder Ganzzahldivision habe, sonst könnte dies viel kürzer sein und ich hätte C und Java überrunden können. Trotzdem liebe ich die Sprache

(λ(x)(if(> x 9)(-(*(+(modulo x 9)1)(expt 10(floor(/ x 9))))1)(+ x 9)))

Hexagony , 40 31 30 Bytes

<_:->.(.+><.'!.\@"9!%>!/{.}|.?

Oder, wenn Sie es vorziehen, dass Ihr Code etwas weniger linear und etwas polygonaler ist:

    < _ : -
   > . ( . +
  > < . ' ! .
 \ @ " 9 ! % >
  ! / { . } |
   . ? . . .
    . . . .

Probieren Sie es online!

Vielen Dank an @FryAmTheEggman für einige Ideen und Anregungen: o)

Vorherige Version: <.:->+_.!(..'!.\><9!%>@.{.}|.?"

Vorgängerversion: <><.-_|@"'!{|(.9+!8=@>{/".'/:!?$.%\1$..\

Perl 6 ,  38   29 Bytes

{$_>9??(1+$_%9)*10**Int($_/9)-1!!$_+9}
{first *.comb.sum==$_,$_^..*}

_{^{(offenbar ist der direkte Ansatz kürzer)}}

Erläuterung:

{
  first
    *.comb.sum == $_, # lambda that does the check
    $_ ^.. *          # Range.new: $_, Inf, :excludes-min
}

Prüfung:

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
   2 => 11,
   8 => 17,
   9 => 18,
  12 => 39,
  16 => 79,
  18 => 99,
  24 => 699,
  32 => 5999,
);

plan +@tests;

my &next-digital-sum = {first *.comb.sum==$_,$_^..*}

for @tests -> $_ ( :key($input), :value($expected) ) {
  is next-digital-sum($input), $expected, .gist;
}

1..8
ok 1 - 2 => 11
ok 2 - 8 => 17
ok 3 - 9 => 18
ok 4 - 12 => 39
ok 5 - 16 => 79
ok 6 - 18 => 99
ok 7 - 24 => 699
ok 8 - 32 => 5999

Java 10, 114 62 Bytes

n->{var r="";for(int i=0;i++<n/9;r+=9);return(n>9?n%9:n+9)+r;}

Probieren Sie es online aus.

EDIT: 130 73 Bytes ohne führende Nullen (Dank an @ levanth` ):

n->{var r="";for(int i=0;i++<n/9;r+=9);return new Long((n>9?n%9:n+9)+r);}

Probieren Sie es online aus.

Erläuterung:

n->                           // Method with integer parameter and long return-type
  var r="";                   //  Result-String, starting empty
  for(int i=0;i++<n/9;r+=9);  //  Append `n` integer-divided by 9 amount of 9's to `r`
  return new Long(            //  Cast String to number to remove any leading zeroes:
    (n>9?                     //   If the input `n` is 10 or larger
      n%9                     //    Use `n` modulo-9
     :                        //   Else (`n` is smaller than 10):
      n+9)                    //    Use `n+9`
    +r);}                     //   And append `r`

Ruby, 33 Bytes

Dies ist eine int-arithmetische Version, die zufällig der Python-Antwort von xnor entspricht. Es ist eine anonyme Funktion, die ein int akzeptiert und zurückgibt.

->n{n<10?n+9:(1+n%9)*10**(n/9)-1}

MathGolf , 8 7 Bytes

Æ)_Σk=▼

Probieren Sie es online!

Implizite Eingabe yay.

Erläuterung:

          Implicit input
 Æ     ▼  Do while false loop that pops the condition
  )       Increment top of stack
   _      Duplicate
    Σ     Get the digit sum
     k    Get input
      =   Is equal?
          Implicit output

Ruby, 38 Bytes

f=->n{n<11?n+9:"#{n<19?n-9:f.(n-9)}9"}

Diese Antwort gibt je nach Eingabegröße eine Zeichenfolge oder ein int zurück. Es ist eine rekursive Lösung, die nach einer Lösung für 9 weniger fragt und am Ende eine "9" hinzufügt.

Ruby, 39 Bytes

f=->n{n<11?n+9:(n<19?n-9:f.(n-9))*10+9}

Für ein weiteres Byte gibt diese Antwort immer ein int zurück. Gleicher Algorithmus wie oben, jedoch mit Zahlen.

C 80 Bytes

i;s;g(j){s=0;for(;j;j/=10)s+=j%10;return s;}f(n){i=n;while(n-g(i))i++;return i;}

Ungolfed online versuchen

int g(int j)
{
    int s=0;
    for(;j;j/=10) s += j%10;
    return s;
}

int f(int n)
{
    int i=n;
    for(;n-g(i);i++);
    return i;
}

PHP, 77 Zeichen

$n=$argv[1];$m=$n+1;while(1){if(array_sum(str_split($m))==$n)die("$m");$m++;}

Oracle SQL 11.2, 165 Byte

SELECT l FROM(SELECT LEVEL l,TO_NUMBER(XMLQUERY(REGEXP_REPLACE(LEVEL,'(\d)','+\1')RETURNING CONTENT)) s FROM DUAL CONNECT BY 1=1)WHERE s=:1 AND l!=s AND rownum=1;

Nicht golfen

SELECT l   
FROM   (
         SELECT LEVEL l, -- Number to evaluate
                XMLQUERY( 
                          REGEXP_REPLACE(LEVEL,'(\d)','+\1')  -- Add a + in front of each digit 
                          RETURNING CONTENT
                        ).GETNUMBERVAL()s                     -- Evaluate le expression generated by the added + 
                FROM DUAL 
                CONNECT BY 1=1 -- Run forever            
       )
WHERE s=:1      -- The sum must be equal to the input
  AND l!=s      -- The sum must not be the input 
  AND rownum=1  -- Keep only the first result

Python 3 55 Bytes

Nimmt zwei Argumente, die gleich sind

f=lambda a,b:a if sum(map(int,str(a)))==b else f(-~a,b)

dh um es zu nennen, würden Sie f (x, x) verwenden

Japt , 9 Bytes

@¶Xìx}aUÄ

Versuch es

Powershell, 54 Bytes

$args|%{(($_+9),+(''+$_%9+'9'*(($_-$_%9)/9)))[$_-gt9]}

Testskript:

$f = {

$args|%{(($_+9),+(''+$_%9+'9'*(($_-$_%9)/9)))[$_-gt9]}

}

@(
    ,(  1,  10   )
    ,(  2 , 11   )
    ,(  8 , 17   )
    ,(  9 , 18   )
    ,( 10,  19   )
    ,( 11,  29   )
    ,( 12 , 39   )
    ,( 16 , 79   )
    ,( 18 , 99   )
    ,( 19 , 199  )
    ,( 24 , 699  )
    ,( 27 , 999  )
    ,( 32 , 5999 )
    ,( 52 , 799999 )
    ,( 128, 299999999999999 )
) | % {
    $a,$e = $_
    $r = &$f $a
    "$($r-eq$e): $r"
}

Ausgabe:

True: 1 : 10
True: 2 : 11
True: 8 : 17
True: 9 : 18
True: 10 : 19
True: 11 : 29
True: 12 : 39
True: 16 : 79
True: 18 : 99
True: 19 : 199
True: 24 : 699
True: 27 : 999
True: 32 : 5999
True: 52 : 799999
True: 128 : 299999999999999

Ausweitung

• ob [$_-gt9] gibt eine erste Ziffer und einen Schwanz zurück
  • eine erste Ziffer ist die Differenz zwischen $ _ und der Summe von 9 ($_%9 )
  • ein Schwanz ist ein paar Neunen - '9'*(($_-$_%9)/9))
  • Konvertiert schließlich eine Ergebniszeichenfolge in eine Zahl, um die führende 0 zu entfernen
• sonst kehrt zurück ($_+9)