È tutto nel titolo ...

Prendi come input un numero intero positivo n>=12e ... fai quello che dice il titolo.

Sì, questo è su OEIS A187924 .

Alcuni casi di test

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

Questo è code-golf . Vince il codice più corto in byte!

Befunge, 81 byte

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

Provalo online!

Può gestire almeno fino a n = 70, dopo di che alcuni valori inizieranno a traboccare la dimensione della cella dello stack sulla maggior parte delle implementazioni e su quelli che non lo fanno, ci vorrà così tanto tempo che non vale la pena aspettare per scoprirlo.

Dati questi vincoli, non ci preoccupiamo nemmeno di provare a gestire valori di n maggiori di 99, il che significa che possiamo testare più facilmente se il valore termina in n confrontando semplicemente il valore modulo 100 con n .

Di seguito è riportato un dettaglio più dettagliato del codice.

Leggi n da stdin e salva in memoria.
Inizializza il valore di test v su 0 e avvia il loop principale, incrementando v in avanti.
Verifica se v%n == 0e se non tornare all'inizio del loop principale.
Verifica se v%100 == ne se non tornare all'inizio del loop principale.
Somma le cifre in v aggiungendo ripetutamente v modulo 10 e dividendo v per 10.
Verifica se la somma è uguale a n e, in caso contrario, ritorna all'inizio del ciclo principale.
Altrimenti uscita v ed uscita.

05AB1E , 14 byte

[NI«ÐIÖsSOIQ*#

Provalo online!

Spiegazione

Le soluzioni che richiedono prefissi di grandi dimensioni scadranno su 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 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>

Accetta l'input come stringa. Ha bisogno di un browser con supporto di ricorsione della coda per risultati più grandi. Modifica: salvato 1 byte grazie a @Arnauld.

Brachylog v2, 12 10 byte

a₁.;A×?≜ẹ+

Provalo online!

Questa è una presentazione di funzioni che accetta input via .e produce output via ?(l'opposto della normale convenzione; tutte le funzioni di Brachylog hanno esattamente due argomenti, che possono essere argomenti di input o output, ma il linguaggio non impone alcun uso particolare di argomento). Noi normalmente non consideriamo convenzioni per l'utilizzo argomento per essere pertinenti al PPCG .

Spiegazione

Una versione precedente di questa soluzione aveva un caso speciale ( Ḋ|cioè "restituisci le cifre alla lettera") per le singole cifre, ma a quanto pare la domanda afferma che non è necessario verificarlo (grazie a @DLosc per averlo rilevato), quindi ho rimosso esso. (La soluzione scritta non funzionerà su singole cifre poiché Brachylog non considererà 1 come una possibilità per uno sconosciuto in una moltiplicazione, per prevenire cicli infiniti; le sue moltiplicazioni sono arbitrarie.)

Quindi questa risposta ora vale per una traduzione praticamente diretta della specifica. A partire da ?(l'output / numero che stiamo cercando di trovare; un predicato di Brachylog inizia sempre implicitamente con ?) usiamo a₁.per affermare che ha .(l'input) come suffisso. Quindi ;A×?significa che possiamo moltiplicare ( ×) il risultato per qualcosa ( ;A) da produrre ?(l'output). Infine, ẹ+somma ( +) le cifre ( ẹ) di ?, e per impostazione predefinita c'è un'asserzione implicita alla fine di ogni programma Brachylog che produce il risultato finale .. Quindi, in altre parole, questo programma è " .è un suffisso di ?, .moltiplicato per qualcosa è ?, .è la somma delle cifre di?", che è molto vicino a una traduzione letterale del programma originale.

Il ≜è necessario per il requisito somma cifre da eseguire. Presumo che qualcosa ẹnon piaccia le incognite, quindi il ≜Brachylog dice di usare un approccio a forza bruta per quella parte del programma piuttosto che l'algebra.

Haskell , 72 byte

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

Provalo online!

Si noti che il numero trovato meno n deve essere un multiplo di n e 10 ^ lunghezza (n).

Ispirato da Laikoni e totalmente umano

Alice , 35 byte

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

Provalo online!

Spiegazione

Questo programma ha un bel mix e un'interazione tra la modalità Cardinale (elaborazione di numeri interi) e Ordinale (elaborazione di stringhe).

Il solito framework per le sfide con I / O decimali che operano in gran parte in modalità Cardinale:

/o 
\i@/...

E il programma attuale:

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

-26 grazie a JollyJoker

-7 grazie ancora a JollyJoker

-11 grazie a Oliver Grégoire

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

Provalo online!

Devi amare Java! Potrebbe essere che sto usando un approccio inefficiente, ma non avendo una funzione di checksum integrata e la doppia conversione in String per verificare la fine del numero di costi byte ...

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 byte

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

-18 byte da @MartinEnder

Provalo online!

Ecco un'altra versione di Martin Ender
Questo approccio può arrivare fino a n=40(41 supera il limite di iterazione predefinito)

Mathematica, 65 byte

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

Provalo online!

Python 2 , 74 byte

Questa soluzione presuppone che n <= sys.maxint.

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

Provalo online!

C (gcc) 71 69 byte, errore su 100

Ho provato con long e% 1000 ma è scaduto

-2 byte grazie 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;}

Provalo online

Buccia , 20 19 17 byte

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

Grazie @Zgarb per -2 byte!

Provalo online!

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

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

Provalo online!

• 6 byte salvati grazie a Emigna e alla mia straordinaria capacità di scrivere (""+n)in alcuni luoghi e n.ToString()in altri.

Julia, 70 byte

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

Ohm v2 , 16 byte

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

Provalo online!

Pip , 18 byte

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

Algoritmo ispirato alla risposta di Emigna . Provalo online!

Come funziona

                    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 byte

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

Haskell , 75 byte

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

Provalo online!

Spiegazione:

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.

Mi chiedo se la parte "finisce in n" possa essere abbreviata. Ho anche provato show n`elem`scanr(:)""(show x), ma è più lungo.

Rubino , 65 63 54 53 byte

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

Provalo online!

Pyth ,  22  21 byte

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

Provalo qui!

Haskell , 75 byte

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

Provalo online!

PowerShell , 84 byte

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

Provalo online!

Costruzione semplice ma comandi lunghi. Timeout su TIO per n=100, ma se impostiamo esplicitamente la ichiusura, viene emesso correttamente.

Questo è solo un semplice forciclo che continua fino a quando una delle condizioni è vera. Le tre condizioni sono 1) $i%$n, cioè abbiamo un resto; 2) $i-notmatch"$n$", cioè, non regex corrisponde all'ultima coppia di cifre; e 3) ([char[]]"$i"-join'+'|iex)-$n, cioè le cifre sommate non sono uguali a $n(qui controllate da semplice sottrazione, poiché i valori diversi da zero sono veritieri). All'interno del loop stiamo semplicemente incrementando $i.

Pertanto, se non abbiamo un resto, la regex corrisponde e i numeri sono uguali, tutte e tre le condizioni lo sono $falsee usciamo dal ciclo. Di conseguenza, possiamo semplicemente uscire $idalla pipeline e l'output è implicito.

PHP, 73 + 1 byte

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

Esegui come pipe con -R.

loop $iattraverso multipli di <input>fino sum_of_digits-<input>e tail_of_i-$nsono falsy; quindi stampa i.

m4, 210 byte

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

Definisce una macro fche calcola la risposta. È un po 'lento, insolitamente, ma prometto che funziona.

Ho pensato che m4 sarebbe carino perché tratta gli interi come stringhe per impostazione predefinita, ma questo è piuttosto male.

Scala, 120 byte

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}

Questo funziona fino a quando n = 70, dopo di che, non vengono rilevati numeri interi. Per un personaggio in più, Intpuò cambiare in aLong e consentire il n > 100calcolo dei valori .

Ecco la versione ungolfed leggermente più lunga:

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 byte

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}

Provalo online!

Terribile funzione R. Incrementa F(inizia alle 0) di nfino a quando non viene trovato un valore che soddisfa le proprietà richieste, che quindi restituisce. L'uso dianydouble un'espressione invia un avviso per ogni iterazione del ciclo, ma non influenza la correttezza.

Timeout su TIO per input sufficientemente grandi (n = 55 o superiore), ma dovrebbe calcolare correttamente la soluzione con sufficiente tempo / spazio.

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

2 byte salvati grazie a Xcali, non sono riuscito a trovare di meglio

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

prima risposta

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

Provalo online

Gelatina , 22 21 byte

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

Provalo online!

Modifica: compresso su un'unica riga

Spiegazione

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?

Mi ci sono volute molte ore per scrivere perché sto imparando Jelly ma ora che ho finito sono così soddisfatto. Per molto tempo non mi sono reso conto di aver bisogno di questo ¤e non sono riuscito a farlo funzionare. Guardare [questo] [1] codice ben spiegato mi ha aiutato a concludere l'affare. Molte altre risposte di Jelly in PPCG mi hanno guidato anche.

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

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

J , 37 33 byte

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

Provalo 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

La preparazione del contatore di iterazioni è ~ 5 volte più veloce ma 5 byte in più:

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

Provalo online!

Incrementando di 100, 27 byte :

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

Provalo online!

Python 2 , 70 byte

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

Provalo online!