Tout est dans le titre ...

Prenez comme entrée un entier positif n>=12et ... faites ce que le titre dit.

Oui, il s’agit du document OEIS A187924 .

Quelques cas de test

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

C'est du code-golf . Le code le plus court en octets gagne!

Befunge, 81 octets

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

Essayez-le en ligne!

Peut traiter au moins n = 70, après quoi certaines valeurs vont déborder de la taille de la pile dans la plupart des implémentations, et pour celles qui ne le font pas, cela prendra tellement de temps qu'il ne vaut pas la peine d'attendre pour le savoir.

Compte tenu de ces contraintes, nous ne cherchons même pas à gérer des valeurs de n supérieures à 99, ce qui signifie que nous pouvons plus facilement vérifier si la valeur se termine par n en comparant simplement la valeur modulo 100 à n .

Vous trouverez ci-dessous une ventilation plus détaillée du code.

Lire n à partir de stdin et enregistrer dans la mémoire.
Initialisez la valeur de test v à 0 et démarrez la boucle principale en incrémentant v en avant.
Testez si v%n == 0, et sinon, revenez au début de la boucle principale.
Testez si v%100 == n, et sinon, revenez au début de la boucle principale.
Faites la somme des chiffres dans v en ajoutant à plusieurs reprises v modulo 10 et en divisant v par 10.
Testez si la somme est égale à n et si ce n'est pas le cas, revenez au début de la boucle principale.
Sinon, affichez v et quittez.

05AB1E , 14 octets

[NI«ÐIÖsSOIQ*#

Essayez-le en ligne!

Explication

Les solutions nécessitant de gros préfixes expireront sur TIO

[                # 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 octets

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>

Prend l'entrée sous forme de chaîne. Nécessite un navigateur avec prise en charge de la récursivité pour des résultats plus larges. Edit: 1 octet enregistré grâce à @Arnauld.

Brachylog v2, 12 à 10 octets

a₁.;A×?≜ẹ+

Essayez-le en ligne!

Il s'agit d'une soumission de fonction qui prend une entrée .et produit une sortie ?(l'inverse de la convention normale; toutes les fonctions de Brachylog ont exactement deux arguments, qui peuvent être des arguments d'entrée ou de sortie, mais le langage n'impose l'utilisation d'aucun argument particulier). Normalement, nous ne considérons pas que les conventions relatives à l’utilisation des arguments soient pertinentes chez PPCG .

Explication

Une version précédente de cette solution avait un cas spécial ( Ḋ|c'est-à-dire "renvoyer les chiffres littéralement") pour les chiffres uniques, mais la question indique apparemment qu'il n'est pas nécessaire de vérifier cela (merci à @DLosc de l'avoir intercepté). J'ai donc supprimé il. (La solution telle qu'elle est écrite ne fonctionnera pas à un chiffre car Brachylog ne considérera pas 1 comme une possibilité d'inconnu dans une multiplication, afin d'éviter des boucles infinies; ses multiplications sont arbitraires.)

Donc, cette réponse va maintenant pour une traduction à peu près directe de la spécification. En commençant par ?(la sortie / nombre que nous essayons de trouver; un prédicat de Brachylog commence toujours implicitement par ?), nous utilisons a₁.pour affirmer qu’il a .(l’entrée) un suffixe. Ensuite ;A×?signifie que nous pouvons multiplier ( ×) le résultat par quelque chose ( ;A) pour produire ?(la sortie). Enfin, ẹ+somme ( +) les digits ( ẹ) de ?, et il y a par défaut une assertion implicite à la fin de chaque programme Brachylog que le résultat final produit .. Donc, en d'autres termes, ce programme est " .est un suffixe de ?, .multiplié par quelque chose est ?, .est la somme du chiffre de?", ce qui est très proche d’une traduction littérale du programme original.

Le ≜est nécessaire pour que la condition de somme de chiffres soit appliquée. Je suppose que quelque chose à propos de ẹne pas aimer les inconnus, alors le ≜dit à Brachylog d'utiliser une approche de force brute pour cette partie du programme plutôt que l'algèbre.

Haskell , 72 octets

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

Essayez-le en ligne!

Notez que le nombre trouvé moins n doit être un multiple de n et de 10 ^ longueur (n).

Inspiré par Laikoni et totalement humain

Alice , 35 octets

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

Essayez-le en ligne!

Explication

Ce programme offre un très bon mélange et une bonne interaction entre les modes Cardinal (traitement des nombres entiers) et Ordinal (traitement des chaînes).

Le cadre habituel pour les défis avec des E / S décimales qui fonctionnent largement en mode Cardinal:

/o 
\i@/...

Et le programme actuel:

!     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 octets

-26 grâce à JollyJoker

-7 encore grâce à JollyJoker

-11 grâce à Oliver Grégoire

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

Essayez-le en ligne!

Je dois aimer Java! Il se pourrait bien que j'utilise une approche inefficace, mais je n'ai pas de fonction de somme de contrôle intégrée ni de double conversion en chaîne pour vérifier la fin du nombre d'octets de coûts ...

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 octets

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

-18 octets de @MartinEnder

Essayez-le en ligne!

Voici une autre version de Martin Ender
Cette approche peut aller jusqu'à n=40(41 dépasse la limite d'itération par défaut)

Mathematica, 65 octets

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

Essayez-le en ligne!

Python 2 , 74 octets

Cette solution suppose que n <= sys.maxint.

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

Essayez-le en ligne!

C (gcc) 71 69 octets, échoue sur 100

J'ai essayé avec long et% 1000 mais expire

-2 octets grâce à 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;}

Essayez-le en ligne

Husk , 20 19 17 bytes

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

Merci @Zgarb pour -2 octets!

Essayez-le en ligne!

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

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

Essayez-le en ligne!

• 6 octets sauvés grâce à Emigna et à mon étrange capacité à écrire (""+n)dans certains endroits et n.ToString()dans d’autres.

Julia, 70 octets

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

Ohm v2 , 16 octets

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

Essayez-le en ligne!

Pip , 18 octets

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

Algorithme inspiré par la réponse d' Emigna . Essayez-le en ligne!

Comment ça marche

                    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 octets

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

Haskell , 75 octets

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

Essayez-le en ligne!

Explication:

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.

Je me demande si la partie "termine dans n" peut être raccourcie. J'ai aussi essayé show n`elem`scanr(:)""(show x), mais c'est plus long.

Ruby , 65 63 54 53 octets

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

Essayez-le en ligne!

Pyth ,  22 à  21 octets

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

Essayez-le ici!

Haskell , 75 octets

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

Essayez-le en ligne!

PowerShell , 84 octets

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

Essayez-le en ligne!

Construction simple mais longues commandes. Le délai d'expiration sur TIO expire n=100, mais si nous définissons explicitement la iproximité, il génère correctement.

Ceci est juste une forboucle simple qui continue tant que l'une des conditions est vraie. Les trois conditions sont 1) $i%$n, c’est-à-dire que nous avons un reste; 2) $i-notmatch"$n$", c’est-à-dire que l’expression rationnelle ne correspond pas aux deux derniers chiffres; et 3) ([char[]]"$i"-join'+'|iex)-$n, c’est-à-dire que les chiffres additionnés ne sont pas égaux à $n(vérifié ici par simple soustraction, car les valeurs non nulles sont vraies). À l'intérieur de la boucle, nous incrémentons simplement $i.

Ainsi, si nous n’avons pas de reste, que les expressions rationnelles correspondent et que les nombres sont égaux, les trois conditions sont remplies. $false et nous sortons de la boucle. En conséquence, nous pouvons simplement laisser $ile pipeline en place, et la sortie est implicite.

PHP, 73 + 1 octets

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

Courez comme un tuyau avec -R.

boucles $ipar multiples de <input>jusqu’à sum_of_digits-<input>et tail_of_i-$nsont faussaires; puis imprime i.

m4, 210 octets

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)')

Définit une macro f qui calcule la réponse. C'est un peu lent - de manière inhabituelle - mais je vous promets que cela fonctionne.

Je pensais que m4 serait bien, car il traite les entiers comme des chaînes par défaut, mais c'est assez mauvais.

Scala, 120 octets

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}

Cela fonctionne jusqu'à n = 70, après quoi les entiers débordent. Pour un caractère supplémentaire, le Intpeut changer en Longet autoriser des valeurs pourn > 100 de soient calculées.

Voici la version un peu plus longue non-lisée:

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 octets

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}

Essayez-le en ligne!

Fonction R terrible. Incrémente F(commence à 0) njusqu'à ce qu'une valeur satisfaisant les propriétés requises soit trouvée, qu'elle renvoie ensuite. L'utilisation de anysur undouble expression envoie un avertissement pour chaque itération de la boucle, mais n'affecte pas l'exactitude.

Le délai d'attente sur TIO est dépassé pour les entrées suffisamment importantes (n = 55 ou plus), mais il convient de calculer correctement la solution compte tenu du temps / espace suffisant.

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

2 octets économisés grâce à Xcali, impossible de trouver mieux

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

première réponse

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

Essayez-le en ligne

Gelée , 22 21 octets

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

Essayez-le en ligne!

Edit: compressé sur une seule ligne

Explication

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?

Cela m'a pris beaucoup d'heures pour écrire parce que j'apprends Jelly mais maintenant que j'ai terminé, je suis tellement satisfait. Pendant longtemps, je n’ai pas réalisé que j’avais besoin de ce logiciel ¤et j’ai été incapable de le faire fonctionner. Regarder [ce] [1] code bien expliqué m'a aidé à sceller l'accord. Beaucoup d'autres réponses de Jelly dans PPCG m'ont également guidé.

Javascript, 224 octets 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;
}
}
}

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

J , 37 33 octets

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

Essayez-le en ligne!

                                ~    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

La présélection du compteur d’itérations est environ 5 fois plus rapide mais plus longue de 5 octets:

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

Essayez-le en ligne!

Incrémentation de 100, 27 octets :

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

Essayez-le en ligne!

Python 2 , 70 octets

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

Essayez-le en ligne!