Está tudo no título ...

Tome como entrada um número inteiro positivo n>=12e ... faça o que o título diz.

Sim, isso está no OEIS A187924 .

Alguns casos de teste

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

Isso é código-golfe . O menor código em bytes vence!

Befunge, 81 bytes

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

Experimente online!

Pode lidar com até n = 70, pelo menos, após o qual alguns valores começarão a exceder o tamanho da célula da pilha na maioria das implementações e naquelas que não o fizerem, levará tanto tempo que não vale a pena esperar para descobrir.

Dadas essas restrições, nem tentamos manipular valores de n maiores que 99, o que significa que podemos testar mais facilmente se o valor termina em n com simplesmente comparando o valor módulo 100 com n .

Abaixo está uma descrição mais detalhada do código.

Leia n do stdin e salve na memória.
Inicialize o valor do teste v para 0 e inicie o loop principal, incrementando v na frente.
Teste se v%n == 0, e se não, retorne ao início do loop principal.
Teste se v%100 == n, e se não, retorne ao início do loop principal.
Soma os dígitos em v adicionando repetidamente v módulo 10 e dividindo v por 10.
Teste se a soma é igual a n e, se não, retorne ao início do loop principal.
Caso contrário, imprima ve saia.

05AB1E , 14 bytes

[NI«ÐIÖsSOIQ*#

Experimente online!

Explicação

As soluções que exigem prefixos grandes expiram no 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>

Recebe a entrada como uma sequência. Precisa de um navegador com suporte à recursão de cauda para obter resultados maiores. Editar: salvou 1 byte graças a @Arnauld.

Brachylog v2, 12 10 bytes

a₁.;A×?≜ẹ+

Experimente online!

Esta é uma submissão de função que recebe entrada via .e produz saída via ?(o oposto da convenção normal; todas as funções Brachylog têm exatamente dois argumentos, que podem ser argumentos de entrada ou saída, mas a linguagem não impõe nenhum uso específico de argumento). Nós normalmente não considerar convenções para o uso do argumento de ser relevante na PPCG .

Explicação

Uma versão anterior desta solução tinha um caso especial ( Ḋ|ou seja, "dígitos de retorno literalmente") para dígitos únicos, mas aparentemente a pergunta afirma que você não precisa verificar isso (obrigado @DLosc por capturar isso), então removi isto. (A solução escrita não funcionará em um dígito, pois Brachylog não considerará 1 como uma possibilidade para um desconhecido em uma multiplicação, para evitar loops infinitos; suas multiplicações são de aridade arbitrária.)

Portanto, esta resposta agora vale para uma tradução direta da especificação. Começando com ?(a saída / número que estamos tentando encontrar; um predicado Brachylog sempre começa implicitamente com ?) usamos a₁.para afirmar que ele tem .(a entrada) como sufixo. Então ;A×?significa que podemos multiplicar ( ×) o resultado por algo ( ;A) a produzir ?(a saída). Finalmente, ẹ+soma ( +) os dígitos ( ẹ) de ?, e há por padrão uma asserção implícita no final de cada programa Brachylog que o resultado final produz .. Portanto, em outras palavras, este programa é " .é um sufixo ?, .multiplicado por algo ?, .é a soma de dígitos de?", que está muito próximo de uma tradução literal do programa original.

A ≜é necessária para a exigência soma dígito a ser aplicadas. Eu suponho que algo sobre ẹnão goste de incógnitas, então o ≜Brachylog diz para usar uma abordagem de força bruta para essa parte do programa, em vez 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

Experimente online!

Observe que o número encontrado menos n deve ser um múltiplo de n e 10 ^ de comprimento (n).

Inspirado por Laikoni e totalmente humano

Alice , 35 bytes

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

Experimente online!

Explicação

Este programa possui uma mistura e interação realmente agradáveis ​​entre o modo Cardinal (processamento inteiro) e Ordinal (processamento de string).

A estrutura usual para desafios com E / S decimal, que operam amplamente no modo Cardinal:

/o 
\i@/...

E o programa atual:

!     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 graças a JollyJoker

-7 novamente graças a JollyJoker

-11 graças a Oliver Grégoire

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

Experimente online!

Conseguiu amar Java! Pode ser que eu esteja usando uma abordagem ineficiente, mas não tendo uma função de soma de verificação incorporada e a conversão dupla em String para verificar o final do número de bytes de custos ...

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

Experimente online!

Aqui está outra versão de Martin Ender
Essa abordagem pode ir até n=40(41 excede o limite de iteração padrão)

Mathematica, 65 bytes

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

Experimente online!

Python 2 , 74 bytes

Esta solução assume isso n <= sys.maxint.

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

Experimente online!

C (gcc) 71 69 bytes, falha em 100

Eu tentei com longo e% 1000, mas o tempo limite

-2 bytes graças ao stablebox

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

Experimente online

Casca , 20 19 17 bytes

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

Obrigado @Zgarb por -2 bytes!

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

Experimente online!

• 6 bytes salvos graças a Emigna e minha estranha capacidade de escrever (""+n)em alguns lugares e n.ToString()em outros.

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

Experimente online!

Pip , 18 bytes

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

Algoritmo inspirado na resposta de Emigna . Experimente online!

Como 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

Experimente online!

Explicação:

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.

Gostaria de saber se a parte "termina em n" pode ser reduzida. Eu também tentei show n`elem`scanr(:)""(show x), mas é mais longo.

Ruby , 65 63 54 53 bytes

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

Experimente online!

Pitão ,  22  21 bytes

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

Experimente aqui!

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

Experimente online!

PowerShell , 84 bytes

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

Experimente online!

Construção simples, mas comandos longos. O tempo limite é excedido no TIO para n=100, mas se definirmos explicitamente ipara fechar, ele será exibido corretamente.

Este é apenas um forloop simples que continua enquanto qualquer uma das condições for verdadeira. As três condições são 1) $i%$n, ou seja, temos um restante; 2) $i-notmatch"$n$", ou seja, não regex corresponde ao último par de dígitos; e 3) ([char[]]"$i"-join'+'|iex)-$n, ou seja, os dígitos somados não são iguais a $n(aqui verificado por subtração simples, pois valores diferentes de zero são verdadeiros). Dentro do loop, estamos simplesmente incrementando $i.

Assim, se não tivermos um restante, a regex corresponde e os números são iguais, todas as três condições são $falsee saímos do loop. Como resultado, podemos apenas deixar $io pipeline e a produção está implícita.

PHP, 73 + 1 bytes

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

Corra como cano com -R.

laços $iatravés de múltiplos de <input>até sum_of_digits-<input>e tail_of_i-$nsão falsas; depois 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 uma macro fque calcula a resposta. É um pouco lento - inutilizável -, mas prometo que funciona.

Eu pensei que m4 seria bom porque trata números inteiros como seqüências de caracteres por padrão, mas isso é muito ruim.

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}

Isso funciona até n = 70, após o qual os números excedem. Para um caractere extra, o Intpode mudar para a Longe permitir que os valores n > 100sejam calculados.

Aqui está a versão não-gasta, um pouco mais longa:

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}

Experimente online!

Terrível função R. Incrementa F(começa em 0) naté que seja encontrado um valor que satisfaça as propriedades necessárias, que ele retornará. O uso de anyem uma doubleexpressão envia um aviso para cada iteração do loop, mas não afeta a correção.

O tempo limite é excedido no TIO para entradas grandes o suficiente (n = 55 ou superior), mas deve calcular corretamente a solução, com tempo / espaço suficiente.

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

2 bytes salvos graças ao Xcali, não conseguiram encontrar melhor

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

primeira resposta

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

Experimente online

Geléia , 22 21 bytes

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

Experimente online!

Editar: compactado em uma única linha

Explicação

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?

Levei muitas horas para escrever porque estou aprendendo Jelly, mas agora que terminei, estou muito satisfeito. Durante muito tempo, não percebi que precisava ¤e simplesmente não consegui fazê-lo funcionar. Olhar para [este] [1] código bem explicado me ajudou a fechar o acordo. Muitas outras respostas da Jelly no PPCG também me guiaram.

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.".\.))":)^:_~

Experimente 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

Anexar o contador de iteração é ~ 5 vezes mais rápido, mas 5 bytes mais:

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

Experimente online!

Incrementando 100, 27 bytes :

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

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

Experimente online!