Auf den Titel kommt es an ...

Nehmen Sie als Eingabe eine positive Ganzzahl n>=12und ... tun Sie, was der Titel sagt.

Ja, dies ist in OEIS A187924 .

Einige Testfälle

12 -> 912  
13 -> 11713  
14 -> 6314  
15 -> 915  
16 -> 3616  
17 -> 15317  
18 -> 918  
19 -> 17119 
20 -> 9920  
40 -> 1999840   
100-> 99999999999100

Das ist Code-Golf . Kürzester Code in Bytes gewinnt!

Befunge, 81 Bytes

&>00p0v<!%g0<
v%"d":_>1+:0^
>00g->#^_:0v
0g10g-#^_.@1>
>0p:55+/\:v>
^1+g01%+55_$^

Probieren Sie es online!

Kann mindestens bis zu n = 70 verarbeiten. Danach überschreiten einige Werte bei den meisten Implementierungen die Stack-Zellengröße, und bei anderen dauert es so lange, dass es sich nicht lohnt, darauf zu warten.

Diese Einschränkungen gegeben, wir nicht einmal die Mühe versucht , Werte zu handhaben n größer als 99, was bedeutet , wir können leichter testen , ob der Wert Enden in n mit , indem Sie einfach den Wert Modulo 100 mit Vergleichen n .

Nachfolgend finden Sie eine detailliertere Aufschlüsselung des Codes.

Lies n von stdin und speichere im Speicher.
Initialisieren Sie den Testwert v auf 0 und starten Sie die Hauptschleife, indem Sie v nach vorne erhöhen .
Testen Sie, ob v%n == 0und kehren Sie an den Anfang der Hauptschleife zurück.
Testen Sie, ob v%100 == nund kehren Sie an den Anfang der Hauptschleife zurück. Addieren Sie
die Ziffern in v, indem Sie wiederholt v modulo 10 addieren und v durch 10 dividieren .
Prüfen Sie, ob die Summe gleich n ist , und kehren Sie an den Anfang der Hauptschleife zurück.
Ansonsten gib v aus und beende.

05AB1E , 14 Bytes

[NI«ÐIÖsSOIQ*#

Probieren Sie es online!

Erläuterung

Bei Lösungen, für die große Präfixe erforderlich sind, tritt bei TIO ein Timeout auf

[                # start a loop
 NI«             # append input to current iteration number
    Ð            # triplicate
     IÖ          # is the first copy evenly divisible by input?
       sSOIQ     # is the digit sum of the second copy equal to the input?
            *    # multiply
             #   # if true, break loop
                 # output the third copy

JavaScript (ES6), 55 54 Byte

f=(s,p=0,a=p+s)=>a%s|eval([...a].join`+`)-s?f(s,p+1):a

<input type=number min=12 oninput=o.textContent=f(this.value)><pre id=o>

Übernimmt die Eingabe als Zeichenfolge. Benötigt einen Browser mit Schwanzrekursionsunterstützung für die größeren Ergebnisse. Bearbeiten: 1 Byte dank @Arnauld gespeichert.

Brachylog v2, 12 10 Bytes

a₁.;A×?≜ẹ+

Probieren Sie es online!

Dies ist eine Funktionsübergabe, die Eingabe über .und Ausgabe über erzeugt ?(im Gegensatz zur normalen Konvention: Alle Brachylog-Funktionen haben genau zwei Argumente, die Eingabe- oder Ausgabeargumente sein können, aber die Sprache erzwingt keine bestimmte Argumentverwendung). Normalerweise halten wir Konventionen für die Verwendung von Argumenten bei PPCG nicht für relevant .

Erläuterung

Eine frühere Version dieser Lösung hatte einen Sonderfall ( Ḋ|dh "Ziffern buchstäblich zurückgeben") für einzelne Ziffern, aber die Frage besagt anscheinend, dass Sie das nicht überprüfen müssen (danke @DLosc, dass Sie dies abgefangen haben), also habe ich es entfernt es. (Die geschriebene Lösung funktioniert nicht mit einzelnen Ziffern, da Brachylog 1 nicht als Möglichkeit für ein Unbekanntes in einer Multiplikation betrachtet, um Endlosschleifen zu verhindern. Die Multiplikationen sind willkürlich.)

Diese Antwort bezieht sich nun auf eine ziemlich direkte Übersetzung der Spezifikation. Beginnend mit ?(der Ausgabe / Zahl, die wir suchen; ein Brachylog-Prädikat beginnt implizit immer mit ?) wird a₁.behauptet, dass es .(die Eingabe) als Suffix hat. Das ;A×?bedeutet dann , dass wir ×das Ergebnis mit etwas multiplizieren können, um es ;Azu produzieren ?. Schließlich ẹ+summiert ( +) die Ziffern ( ẹ) von ?und am Ende jedes Brachylog-Programms, das das Endergebnis erzeugt, steht standardmäßig eine implizite Zusicherung .. Mit anderen Worten, dieses Programm ist " .ist ein Suffix von ?, .multipliziert mit etwas ?, .ist die Ziffernsumme von?", was einer wörtlichen Übersetzung des ursprünglichen Programms sehr nahe kommt.

Dies ≜ist erforderlich, damit die Ziffernsummenanforderung durchgesetzt wird. Ich nehme an, dass etwas ẹUnbekanntes nicht mag, und so fordert das ≜Brachylog dazu auf, einen Brute-Force-Ansatz für diesen Teil des Programms anstelle von Algebra zu verwenden.

Haskell , 72 Bytes

f n=[x|x<-[n,n+lcm n(10^length(show n))..],sum[read[j]|j<-show x]==n]!!0

Probieren Sie es online!

Beachten Sie, dass die gefundene Zahl minus n ein Vielfaches von n und 10 ^ Länge (n) sein muss.

Inspiriert von Laikoni und total menschlich

Alice , 35 Bytes

/o
\i@/!w?+.?~\ & /-$K..?\ L z $ /K

Probieren Sie es online!

Erläuterung

Dieses Programm bietet eine sehr gute Mischung und Interaktion zwischen dem Cardinal-Modus (Integer-Verarbeitung) und dem Ordinal-Modus (String-Verarbeitung).

Das übliche Framework für Herausforderungen mit dezimaler E / A, die hauptsächlich im Kardinalmodus ausgeführt werden:

/o 
\i@/...

Und das eigentliche Programm:

!     Store the input N on the tape.
      We'll use an implicit zero on top of the stack as our iterator variable X,
      which searches for the first valid result.
w     Store the current IP position on the return address stack. This marks
      the beginning of the main search loop. We can avoid the divisibility
      test by going up in increments of N. To check the other two 
      conditions, we'll use individual conditional loop ends that skip to 
      the next iteration. Only if both checks pass and all loop ends are 
      skipped will the search terminate.

  ?+    Increment the iterator X by N.
  .     Duplicate X.
  ?~    Put a copy of N underneath.
  \     Switch to Ordinal mode.
  &     Implicitly convert X to a string, then fold the next command over its
        characters, i.e. its digits. Here, "fold" means that each character
        is pushed to the stack in turn, followed by one execution of that
        next command.
  /     Switch back to Cardinal mode (this is not a command).
  -     Fold subtraction over the digits. This implicitly converts each 
        digit back to its numerical value and subtracts it from N. If the
        digit sum of X is equal to N, this will result in 0.
  $K    Jump back to the w if the digit sum of X isn't N.
  ..    Duplicate X twice.
  ?     Get a copy of N.
  \     Switch to Ordinal mode.
  L     Shortest common superstring. Implicitly converts X and N to strings
        and gives the shortest string that starts with X and ends with N. 
        This will be equal to X iff X already ends with N. Call this Y.
  z     Drop. If X contains Y, this deletes everything up to and including
        Y from X. This can only happen if they are equal, i.e. if X ended
        with N. Otherwise X remains unchanged.
  $     Skip the next command if the string is empty, i.e. if X ended with N.
  /     Switch back to Cardinal mode.
  K     Jump back to w if X didn't end with N.

Java (OpenJDK 8) , 136 110 103 92 Bytes

-26 danke an JollyJoker

-7 Nochmals vielen Dank an JollyJoker

-11 danke an Oliver Grégoire

a->{for(int i=a;!(""+a).endsWith(""+i)|i!=(""+a).chars().map(x->x-48).sum();a+=i);return a;}

Probieren Sie es online!

Muss Java lieben! Es könnte gut sein, dass ich einen ineffizienten Ansatz verwende, aber keine eingebaute Prüfsummenfunktion und die doppelte Konvertierung in String, um nach dem Ende der Zahl zu suchen, Bytes kostet ...

Ungolfed:

  a->{                                                       //input n (as integer)
      for (int i = a;                                        //initiate loop
           !("" + a).endsWith("" + i)                        //check if the calculated number ends with the input
           | i != ("" + a).chars().map(x -> x - 48).sum();   //check if the checksum is equal to the input
           a += i)                                           //for every iteration, increase i by the input to save checking for divisibility
        ;                                                    //empty loop body, as everything is calculated in the header
    return a;                                                //return number
}

Mathematica, 72 Bytes

(t=#;While[Mod[t,10^IntegerLength@#]!=#||Tr@IntegerDigits@t!=#,t+=#];t)&  

-18 Bytes von @MartinEnder

Probieren Sie es online!

Hier ist eine andere Version von Martin Ender.
Dieser Ansatz kann bis zu n=40(41 überschreitet das Standard-Iterationslimit) gehen.

Mathematica, 65 Bytes

#//.t_/;Mod[t,10^IntegerLength@#]!=#||Tr@IntegerDigits@t!=#:>t+#&

Probieren Sie es online!

Python 2 , 74 Bytes

Diese Lösung geht davon aus n <= sys.maxint.

n=x=input()
while sum(map(int,str(x)))-n*str(x).endswith(`n`):x+=n
print x

Probieren Sie es online!

C (gcc) 71 69 Bytes, schlägt bei 100 fehl

Ich habe es mit long und% 1000 aber mal ausprobiert

-2 Bytes dank Steadybox

s,i,j;f(n){for(j=0;s^n|j%100!=n;)for(s=0,i=j+=n;i;i/=10)s+=i%10;j=j;}

Probieren Sie es online aus

Schale , 20 - 19 - 17 Bytes

ḟȯ=⁰Σdfȯ€d⁰ṫdm*⁰N

Danke @Zgarb für -2 Bytes!

Probieren Sie es online!

C # (.NET Core) , 90 84 83 + 18 = 101 Bytes

using System.Linq;
n=>{for(int i=n;!(""+n).EndsWith(""+i)|n%i>0|(""+n).Sum(c=>c-48)!=i;n++);return n;}

Probieren Sie es online!

• 6 Bytes gespart dank Emigna und meiner unheimlichen Fähigkeit, (""+n)an einigen Stellen und n.ToString()an anderen zu schreiben .

Julia, 70 Bytes

f(x)=(n=x;while(sum(digits(n))!=x||x!=n%(10^length("$x")));n+=x;end;n)

Ohm v2 , 16 Bytes

£^›u³↔ξ³¥s}Σ³E*‽

Probieren Sie es online!

Pip , 18 Bytes

T!y%a&$+y=aY++i.ay

Algorithmus inspiriert von Emignas Antwort . Probieren Sie es online!

Wie es funktioniert

                    a is 1st cmdline arg, i is 0, y is "" (implicit)
T                   Loop until
 !y%a&              y%a is 0 and
      $+y=a         sum of y is a:
            ++i      Increment i
           Y   .a    and yank (i concat a) into y
                 y  After the loop exits, autoprint y

JavaScript REPL (ES5), 60 59 Bytes

for(n=prompt(i=0);eval([].join.call(t=++i+n,'+'))-n|t%n;);t

Haskell , 75 Bytes

f n=[x|x<-[0,n..],sum[read[d]|d<-show x]==n,mod x(10^length(show n))==n]!!0

Probieren Sie es online!

Erläuterung:

f n=[x|                                      ]!!0 -- Given input n, take the first x
       x<-[0,n..],                                -- which is a multiple of n,
                  sum[read[d]|d<-show x]==n,      -- has a digital sum of n
                  mod x(10^length(show n))==n     -- and ends in n.

Ich frage mich, ob der Teil "endet in n" verkürzt werden kann. Ich habe es auch versucht show n`elem`scanr(:)""(show x), aber es ist länger.

Ruby , 65 63 54 53 Bytes

->n{a=n;a+=n until/#{n}$/=~a.to_s&&a.digits.sum==n;a}

Probieren Sie es online!

Pyth ,  22  21 Bytes

fq2-/,%T^;l`QsjT;Q%TQ

Probieren Sie es hier aus!

Haskell , 75 Bytes

f n=[i|i<-[n,n+10^length(show$n)..],i`mod`n<1,sum[read[j]|j<-show$i]==n]!!0

Probieren Sie es online!

PowerShell , 84 Byte

for($n=$i=$args[0];$i%$n-or$i-notmatch"$n$"-or([char[]]"$i"-join'+'|iex)-$n){$i++}$i

Probieren Sie es online!

Einfacher Aufbau, aber langwierige Befehle. Timeout bei TIO für n=100, aber wenn wir explizit iauf close setzen, wird es korrekt ausgegeben.

Dies ist nur eine einfache forSchleife, die so lange fortgesetzt wird, wie eine der Bedingungen erfüllt ist. Die drei Bedingungen sind 1) $i%$n, dh wir haben einen Rest; 2) $i-notmatch"$n$", dh es stimmt nicht mit den letzten Ziffern überein; und 3) ([char[]]"$i"-join'+'|iex)-$n, dh die $nSumme der Ziffern ist ungleich (hier durch einfache Subtraktion überprüft, da Werte ungleich Null wahr sind). Innerhalb der Schleife werden wir einfach erhöht $i.

Wenn wir also keinen Rest haben, stimmt der reguläre Ausdruck überein und die Zahlen sind gleich. Alle drei Bedingungen sind erfüllt $falseund wir verlassen die Schleife. Infolgedessen können wir einfach $iin der Pipeline verbleiben und die Ausgabe ist implizit.

PHP, 73 + 1 Bytes

while(array_sum(str_split($i+=$n=$argn))-$n|$i%10**strlen($n)-$n);echo$i;

Als Rohr mit laufen lassen -R.

Schleifen $idurch ein Vielfaches von <input>bis zu sum_of_digits-<input>und tail_of_i-$nsind falsy; dann druckt i.

m4, 210 Bytes

define(d,define)d(i,ifelse)d(s,`i($1,,0,`eval(substr($1,0,1)+s(substr($1,1)))')')d(k,`r($1,eval($2+1))')d(r,`i(s($2),$1,i(regexp($2,$1$),-1,`k($1,$2)',i(eval($2%$1),0,$2,`k($1,$2)')),`k($1,$2)')')d(f,`r($1,1)')

Definiert ein Makro f, das die Antwort berechnet. Es ist ein bisschen langsam - ungewöhnlich - aber ich verspreche, dass es funktioniert.

Ich dachte, m4 wäre schön, weil es Ganzzahlen standardmäßig als Zeichenfolgen behandelt, aber das ist ziemlich schlecht.

Scala, 120 Bytes

def a(n:Int)={val b=math.pow(10,math.ceil(math.log10(n))).##;var c=b+n;while(c%n!=0||(0/:c.toString)(_+_-'0')!=n)c+=b;c}

Dies funktioniert bis zum n = 70Überlauf von ganzen Zahlen. Für ein zusätzliches Zeichen Intkann das in a geändert werden, Longund es können Werte n > 100berechnet werden.

Hier ist die etwas längere ungolfed Version:

def golfSourceLong(n: Long): Long = {
  val delta = math.pow(10, math.ceil(math.log10(n))).toInt
  var current = delta + n
  while (current % n != 0 || current.toString.foldLeft(0)(_ + _ - '0') != n) {
    current += delta
  }
  current
}

R , 115 Bytes

function(n,d=nchar(n):1){while(sum(D<-F%/%10^((k=nchar(F)):1-1)%%10)-n|any(D[k-d+1]-n%/%10^(d-1)%%10)|F%%n)F=F+n
F}

Probieren Sie es online!

Schreckliche R-Funktion. Inkrementiert F(beginnt um 0), nbis ein Wert gefunden wird, der die erforderlichen Eigenschaften erfüllt, und gibt ihn dann zurück. Die Verwendung von anyon für einen doubleAusdruck gibt für jede Iteration der Schleife eine Warnung aus, hat jedoch keinen Einfluss auf die Korrektheit.

Zeitüberschreitung bei TIO für ausreichend große Eingaben (n = 55 oder höher), sollte aber die Lösung bei genügend Zeit / Raum korrekt berechnen.

Perl 5, 46 44 + 1 (-p) = 45 Bytes

2 Bytes gespart dank Xcali, besser nicht zu finden

($\=++$t.$_)%$_|$_-eval$\=~s//+/gr.0&&redo}{

erste antwort

$\=++$x.$_;eval$\=~s//+/gr."-$_"|$\%$_&&redo}{

Probieren Sie es online aus

Jelly , 22 21 Bytes

DS=³a³ḍaDṫ³DLC¤Ḍ=³ø1#

Probieren Sie es online!

Bearbeiten: Auf eine einzelne Zeile komprimiert

Erläuterung

DS=³a³ḍaDṫ³DLC¤Ḍ=³ø1#
                  ø1#  Evaluate the condition before this and increment a counter until it is met then output the counter                     
D                      Digits of incremented variable as a list
 S                     Sum
  =³                   Equals argument of program?
    a                  Logical and
     ³ḍ                Does arg divide incremented variable?
       a               Logical and
        Dṫ     Ḍ       Last n digits of inc. var. where n is number of digits in program input
          ³DLC         1 - (number of digits of program input)
              ¤        Book ends above nilad
                =³     Equals program input?

Ich habe viele Stunden gebraucht, um zu schreiben, weil ich Jelly gelernt habe, aber jetzt, wo ich fertig bin, bin ich so zufrieden. Lange wusste ich nicht, dass ich das brauchte ¤und ich konnte es einfach nicht zum Laufen bringen. Ein Blick auf [diesen] [1] gut erklärten Code hat mir geholfen, den Deal zu besiegeln. Viele andere Jelly-Antworten in PPCG haben mich auch angeleitet.

Javascript, 224 Bytes function getNumber(x){if(x<12){return!1};const sumDigits=(x)=>x.toString().split('').map(Number).reduce((a,b)=>a+b,0);for(let i=2;i<9999;i++){if((x*i-x)%(Math.pow(10,x.toString().length))==0&&sumDigits(x*i)==x){return x*i}}} Un-Golf:

function getNumber(x){
	if (x<12) {return false};
	const sumDigits = (x) => x.toString().split('').map(Number).reduce((a,b)=>a+b, 0);
	for (let i=2; i<9999; i++){
		if((x*i-x)%(Math.pow(10, x.toString().length))==0 && sumDigits(x*i)==x){
			return x*i;
}
}
}

Verwendung: 1. getNumber (12) 2. getNumber (13) 3. ....

J , 37-33 Bytes

+^:(((=1#."."0)*:(e.".\.))":)^:_~

Probieren Sie es online!

                                ~    A = N
+^:                          ^:_     while(...)A+=N; return A
   (                      ":)        A to string
   (((    "."0)          )  )        digits of A
   ((( 1#.    )          )  )        sum
   (((=       )          )  )        equals N
   ((            (e.".\.))  )        N is one of the suffixes of A-string
   ((          *:        )  )        not AND

Das Voranstellen des Iterationszählers ist ~ 5-mal schneller, aber 5 Byte länger:

(]+[((=1#.,.&.":)<:|),~&.":)^:_&1,&":]

Probieren Sie es online!

Inkrementierung um 100, 27 Bytes :

(]+100*(=1#.,.&.":)<:|)^:_~

Probieren Sie es online!

Python 2 , 70 Bytes

f=lambda n,x=0:x*(x%n<sum(map(int,`x`))==n==x%10**len(`n`))or f(n,x+n)

Probieren Sie es online!