Todo está en el título ...

Tome como entrada un entero positivo n>=12y ... haga lo que dice el título.

Sí, esto está en OEIS A187924 .

Algunos casos de prueba

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

Este es el código de golf . ¡El código más corto en bytes gana!

Befunge, 81 bytes

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

Pruébalo en línea!

Puede manejar hasta n = 70 al menos, después de lo cual algunos valores comenzarán a desbordar el tamaño de celda de la pila en la mayoría de las implementaciones, y en aquellos que no lo hagan, tomará tanto tiempo que no vale la pena esperar para descubrirlo.

Dadas esas restricciones, ni siquiera nos molestamos en tratar de manejar valores de n mayores que 99, lo que significa que podemos probar más fácilmente si el valor termina en n simplemente comparando el módulo de valor 100 con n .

A continuación se muestra un desglose más detallado del código.

Leer n de stdin y guardar en la memoria.
Inicialice el valor de prueba v a 0 e inicie el bucle principal, incrementando v por adelantado.
Pruebe si v%n == 0, y si no, regrese al inicio del bucle principal.
Pruebe si v%100 == n, y si no, regrese al inicio del bucle principal.
Suma los dígitos en v agregando repetidamente v módulo 10 y dividiendo v entre 10.
Comprueba si la suma es igual a n , y si no, regresa al inicio del ciclo principal.
De lo contrario, salida v y salir.

05AB1E , 14 bytes

[NI«ÐIÖsSOIQ*#

Pruébalo en línea!

Explicación

Las soluciones que requieren prefijos grandes se agotarán en 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 bytes

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>

Toma la entrada como una cadena. Necesita un navegador con soporte de recursividad de cola para obtener resultados más grandes. Editar: guardado 1 byte gracias a @Arnauld.

Brachylog v2, 12 10 bytes

a₁.;A×?≜ẹ+

Pruébalo en línea!

Esta es una presentación de función que toma entrada vía .y produce salida vía ?(lo contrario de la convención normal; todas las funciones de Brachylog tienen exactamente dos argumentos, que pueden ser argumentos de entrada o salida, pero el lenguaje no impone ningún uso de argumento en particular). Nosotros normalmente no consideramos convenciones para el uso del argumento para ser relevantes en PPCG .

Explicación

Una versión anterior de esta solución tenía un caso especial ( Ḋ|es decir, "devolver dígitos literalmente") para un solo dígito, pero la pregunta aparentemente indica que no tiene que verificar eso (gracias @DLosc por detectar esto), así que eliminé eso. (La solución tal como está escrita no funcionará en un solo dígito, ya que Brachylog no considerará 1 como una posibilidad para un desconocido en una multiplicación, para evitar bucles infinitos; sus multiplicaciones son arbitrarias).

Entonces, esta respuesta ahora va para una traducción bastante directa de la especificación. Comenzando con ?(la salida / número que estamos tratando de encontrar; un predicado de Brachylog siempre comienza implícitamente con ?) usamos a₁.para afirmar que tiene .(la entrada) como sufijo. Entonces ;A×?significa que podemos multiplicar ( ×) el resultado por algo ( ;A) para producir ?(la salida). Finalmente, ẹ+suma ( +) los dígitos ( ẹ) de ?, y por defecto hay una aserción implícita al final de cada programa Brachylog que produce el resultado final .. En otras palabras, este programa es " .es un sufijo de ?, .multiplicado por algo es ?, .es la suma de dígitos de?", que está muy cerca de una traducción literal del programa original.

El ≜es necesaria para el requisito de suma de dígitos a ser ejecutada. Supongo que algo ẹno le gustan las incógnitas, por lo que ≜le dice a Brachylog que use un enfoque de fuerza bruta para esa parte del programa en lugar de álgebra.

Haskell , 72 bytes

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

Pruébalo en línea!

Tenga en cuenta que el número encontrado menos n debe ser un múltiplo de n y 10 ^ de longitud (n).

Inspirado por Laikoni y totalmente humano

Alice , 35 bytes

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

Pruébalo en línea!

Explicación

Este programa tiene una mezcla e interacción realmente agradable entre el modo Cardinal (procesamiento de enteros) y Ordinal (procesamiento de cadenas).

El marco habitual para los desafíos con E / S decimal que operan principalmente en modo Cardinal:

/o 
\i@/...

Y el programa actual:

!     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 gracias a JollyJoker

-7 de nuevo gracias a JollyJoker

-11 gracias a Oliver Grégoire

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

Pruébalo en línea!

Tengo que amar Java! Bien podría ser que estoy usando un enfoque ineficiente, pero no tengo una función de suma de verificación incorporada y la doble conversión a Cadena para verificar el final del número cuesta bytes ...

Sin golf:

  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 de @MartinEnder

Pruébalo en línea!

Aquí hay otra versión de Martin Ender
Este enfoque puede subir n=40(41 excede el límite de iteración predeterminado)

Mathematica, 65 bytes

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

Pruébalo en línea!

Python 2 , 74 bytes

Esta solución asume eso n <= sys.maxint.

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

Pruébalo en línea!

C (gcc) 71 69 bytes, falla en 100

Lo intenté con long y% 1000 pero el tiempo de espera

-2 bytes gracias a 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;}

Pruébalo en línea

Casco , 20 19 17 bytes

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

¡Gracias @Zgarb por -2 bytes!

Pruébalo en línea!

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;}

Pruébalo en línea!

• 6 bytes guardados gracias a Emigna y mi extraña habilidad para escribir (""+n)en algunos lugares y n.ToString()en otros.

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*‽

Pruébalo en línea!

Pip , 18 bytes

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

Algoritmo inspirado en la respuesta de Emigna . Pruébalo en línea!

Cómo funciona

                    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

Pruébalo en línea!

Explicación:

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.

Me pregunto si la parte "termina en n" puede acortarse. También lo intenté show n`elem`scanr(:)""(show x), pero es más largo.

Ruby , 65 63 54 53 bytes

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

Pruébalo en línea!

Pyth ,  22  21 bytes

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

Pruébalo aquí!

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

Pruébalo en línea!

PowerShell , 84 bytes

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

Pruébalo en línea!

Construcción simple pero comandos largos. Se agota el tiempo de espera de TIO para n=100, pero si establecemos explícitamente iestar cerca, se genera correctamente.

Este es solo un forciclo simple que continúa siempre que cualquiera de las condiciones sea verdadera. Las tres condiciones son 1) $i%$n, es decir, tenemos un resto; 2) $i-notmatch"$n$", es decir, no regex coincide con los últimos dos dígitos; y 3) ([char[]]"$i"-join'+'|iex)-$n, es decir, los dígitos sumados juntos no son iguales a $n(verificados aquí por simple resta, ya que los valores distintos de cero son verdaderos). Dentro del bucle simplemente estamos incrementando $i.

Por lo tanto, si no tenemos un resto, la expresión regular coincide y los números son iguales, las tres condiciones lo son $falsey salimos del ciclo. Como resultado, solo podemos dejar $ien la tubería, y la salida es implícita.

PHP, 73 + 1 bytes

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

Ejecutar como tubería con -R.

recorre $imúltiples de <input>hasta sum_of_digits-<input>y tail_of_i-$nson falsos; Luego imprime 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)')

Define una macro fque calcula la respuesta. Es un poco lento, inutilizable, pero prometo que funciona.

Pensé que m4 sería bueno porque trata los enteros como cadenas por defecto, pero esto es bastante malo.

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}

Esto funciona hasta n = 70, después de lo cual los enteros se desbordan. Para un carácter adicional, Intpuede cambiar a Longay permitir que se calculen los valores n > 100.

Aquí está la versión ungolfing un poco más larga:

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}

Pruébalo en línea!

Terrible función R. Incrementa F(comienza en 0) nhasta que se encuentra un valor que satisface las propiedades requeridas, que luego devuelve. El uso de anyen una doubleexpresión envía una advertencia para cada iteración del bucle, pero no afecta la corrección.

Se agota el tiempo de espera en TIO para entradas lo suficientemente grandes (n = 55 o superior) pero debe calcular correctamente la solución dado el tiempo / espacio suficiente

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

2 bytes guardados gracias a Xcali, no pude encontrar nada mejor

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

primera respuesta

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

Pruébalo en línea

Jalea , 22 21 bytes

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

Pruébalo en línea!

Editar: comprimido a una sola línea

Explicación

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?

Me tomó muchas horas escribir porque estoy aprendiendo Jelly, pero ahora que he terminado, estoy muy satisfecho. Durante mucho tiempo no me di cuenta de que necesitaba el ¤y simplemente no pude hacerlo funcionar. Mirar el código bien explicado [esto] [1] me ayudó a cerrar el trato. Muchas otras respuestas de Jelly en PPCG también me guiaron.

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;
}
}
}

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

J , 37 33 bytes

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

Pruébalo en línea!

                                ~    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

Anteponer el contador de iteraciones es ~ 5 veces más rápido pero 5 bytes más:

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

Pruébalo en línea!

Incrementando en 100, 27 bytes :

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

Pruébalo en línea!

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)

Pruébalo en línea!