"Suma digital" se refiere a la suma de todos los dígitos de un número.

Por ejemplo, la suma digital de 1324es 10, porque 1+3+2+4 = 10.

El desafío es escribir un programa / función para calcular el número más pequeño más grande que la entrada cuya suma digital es la entrada.

Ejemplo con tutorial

Como ejemplo, tome el número 9como entrada:

9 = 1+8 -> 18
9 = 2+7 -> 27
9 = 3+6 -> 36
...
9 = 8+1 -> 81
9 = 9+0 -> 90

La salida válida sería el número más pequeño anterior, que es 18.

Especificaciones

Tenga en cuenta que 9este resultado no es válido para este ejemplo, porque el número invertido debe ser mayor que el número original.

Tenga en cuenta que la entrada será positiva.

Casos de prueba:

 2 => 11      (2 = 1 + 1)
 8 => 17      (8 = 1 + 7)
12 => 39     (12 = 3 + 9)
16 => 79     (16 = 7 + 9)
18 => 99     (18 = 9 + 9)
24 => 699    (24 = 6 + 9 + 9)
32 => 5999   (32 = 5 + 9 + 9 + 9)

Referencias

Este es OEIS A161561 .

Editar: se agregó un caso de prueba adicional (18)

Gracias a Martin Ender por el fragmento de la tabla de posiciones

var QUESTION_ID=81047,OVERRIDE_USER=31373;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

05AB1E, 19 17 8 bytes

Código:

[>DSO¹Q#

Explicado:

[            # start infinite loop
 >           # increase loop variable, will initially be input
  DSO        # make a copy and sum the digits
     ¹Q#     # if it equals the input, break
             # else return to start of loop
             # implicitly print

Pruébalo en línea

Editar: guardado 9 bytes gracias a @Adnan

Python 2, 33 bytes

lambda n:[n+9,`n%9`+n/9*'9'][n>9]

Una expresión directa Crea una cadena de números con 9 al final y el resto al principio. Excepto, para un solo dígito n, da n+9.

Algunas salidas tienen ceros a la izquierda ( 099para 18).

Retina , 39 31 bytes

r`1{1,9}
$.&
T`d`_d`^.$
^.$
1$&

Toma entrada en unario .

Pruébalo en línea! (Las dos primeras líneas permiten ejecutar varios casos de prueba a la vez y se convierten de decimal a unario por conveniencia).

En realidad, esto no busca el resultado linealmente, sino que lo calcula explícitamente:

• Si la entrada nes mayor que 9, la reemplazamos con nueves n % 9seguidos por n / 9(pisos).
• De lo contrario, lo reemplazamos con n + 9.

Usando !(o cualquier otra cosa que no sea 1) como dígito unario, puedo guardar un byte más con el siguiente enfoque:

^!(?!!{9})
1
r`!{0,9}
$.&
0\B

Pero este formato de entrada es un poco exagerado, creo.

Pyth , 8 bytes

fqQsjT;h

Banco de pruebas.

fqQsjT;h

f      h first number T from (input+1) onward where:
 qQ          the input is equal to
   s         the sum of
    jT;      the base-10 representation of T

Java 7, 68 61 bytes

int f(int n){return n>9?-~(n%9)*(int)Math.pow(10,n/9)-1:n+9;}

Hace aproximadamente lo mismo que muchas de las otras respuestas aquí. Quería mostrar el enfoque de Java sin utilizar la manipulación de cadenas y bucles.

Gracias a FryAmTheEggman por recordarme que soy tonto;)

MATL , 10 9 bytes

`QtV!UsG-

Pruébalo en línea!

Explicación

`        % Do...while
  Q      %   Add 1. Takes input implicitly the first time
  t      %   Duplicate
  V!Us   %   To string, transpose, to number, sum. Gives sum of digits
  G-     %   Subtract input. If 0, the loop ends and the stack is implicitly displayed

JavaScript (ES7), 32 bytes

n=>(n%9+1)*10**(n/9|0)-(n>9||-8)

38 bytes como ES6:

n=>parseFloat(n%9+1+'e'+n/9)-(n>9||-8)

Python 3, 128 94 84 74 Bytes

Sin salida, enfoque directo, codegolfer principiante;)

def r(n):
 m=n
 while 1:
  m+=1
  if sum(map(int,str(m)))==n:return(m)

En realidad, 17 bytes

╗1`;$♂≈Σ╜;)=)>*`╓

Pruébalo en línea!

Explicación:

╗1`;$♂≈Σ╜;)=)>*`╓
╗                  save input to reg0
 1`;$♂≈Σ╜;)=)>*`╓  first integer n (>= 0) where:
   ;$♂≈Σ╜;)=         the base-10 digital sum equals the input and
            )>*      is greater than the input

C 73 65 bytes

Una macro con una función auxiliar.

e(y){return y?10*e(y-1):1;}
#define F(n) n<9?n+9:(1+n%9)*e(n/9)-1

La efunción solo calcula potencias de diez, y la Fmacro usa el mismo método de resolución que este rubí y esta respuesta de Python . lamentablemente, es más largo que aproximadamente la misma longitud que ambas respuestas juntas. Pero es la primera respuesta de C.

(8 bytes guardados por el truco de eliminación de Lynn int).

Brachylog , 8 bytes (no competidor)

<.=:ef+?

= se modificó después de que se publicó este desafío, por lo que ahora funciona en dominios posiblemente infinitos, que es el caso aquí.

Explicación

<.       Output > Input
  =      Label the Output (i.e. unify it with an integer)
   :ef   Get the list of digits of the Output
      +? Input is the sum of all those digits

Esto retrocederá =hasta que el valor de Salida haga que todo este predicado sea verdadero.

TSQL (sqlserver 2012), 107 99 bytes

DECLARE @ INT = 32

,@2 char(99)WHILE @>0SELECT
@2=concat(x,@2),@-=x FROM(SELECT IIF(@>9,9,IIF(@2>0,@,@-1))x)y PRINT @2

Pruébalo en línea!

Python 2, 39 bytes

lambda n:[n+9,(1+n%9)*10**(n/9)-1][n>9]

Aritmética entera pura.

Programa completo con salida

f=lambda n:[n+9,(1+n%9)*10**(n/9)-1][n>9]

print(f(2))
print(f(8))
print(f(12))
print(f(16))
print(f(17))
print(f(18))
print(f(24))
print(f(32))

Salida:

11
17
39
79
89
99
699
5999

PowerShell v2 +, 62 bytes

param($n)for($a=$n+1;([char[]]"$a"-join'+'|iex)-ne$n;$a++){}$a

Toma entrada y $nluego ejecuta un forbucle. Inicializamos el ciclo configurando nuestro número objetivo $a, para que sea uno más grande que $n(ya que tiene que ser más grande, además de que esto garantiza que 1..9funcione correctamente). Cada ciclo que incrementamos $a++. Nada sucede en el bucle propiamente dicho, pero el condicional es donde ocurre la lógica del programa. Literalmente estamos tomando el número objetivo como una cadena, convirtiéndolo como una matriz de caracteres, -joinagregando la matriz +y luego canalizándola a iex(similar a eval). Probamos si es igual a nuestro número de entrada o no, y continuamos haciendo el bucle correspondiente. Una vez que hemos salido del ciclo, hemos llegado a donde nuestro número objetivo es la suma de dígitos igual a nuestro número de entrada, por lo que $ase coloca en la tubería y la salida es implícita.

Como referencia, aquí está el método de "construir una cadena con el número apropiado de 9" que otras personas han hecho, a 67 bytes

param($n)(($n+9),(+(""+($n%9)+'9'*(($n/9)-replace'\..*'))))[$n-gt9]

o el método de "aritmética de enteros puros" que otras personas han hecho, a 70 bytes

param($n)(($n+9),("(1+$n%9)*1e$(($n/9)-replace'\..*')-1"|iex))[$n-gt9]

Ninguno de los dos es más corto, pero los dos son más interesantes.

Pyke, 9 8 7 bytes, no competidor - usa una versión más reciente

.fhsq)h

Pruébalo aquí!

.f      - first where true:
  h     - n+1
   sq    - digital_root(^) == input()
      h - that number +1

JavaScript (ES2015), 45 39 33 bytes

Ahorré otros 6 bytes gracias a @Conor O'Brien y @Shaun H.
Creo que lo dejaré como está, porque esta versión difiere de la respuesta de @ Neil al usar String.repeat().

v=>+(v>9?v%9+'9'.repeat(v/9):v+9)

Versión anterior (guardado 6 bytes gracias a @Qwertiy):

f=v=>+(v/9>1?v%9+'9'.repeat(v/9|0):v+9)

Primera versión:

f=v=>+(v/9>1?v%9+'9'.repeat(~~(v/9)):'1'+v-1)

Lua, 52 bytes

n=...+0
print(n>9 and(n%9)..string.rep(9,n/9)or n+9)

Se debe guardar en un archivo y ejecutar con el intérprete de Lua, p. Ej. lua <file> <input number>

También puedes probarlo aquí: https://repl.it/CXom/1

(En la respuesta, el número de entrada está codificado para facilitar la prueba)

Raqueta 70 caracteres, 71 bytes

El mismo algoritmo que la mayoría de los demás. Bastante triste por no tener% para módulo, o ** para expt, o división entera por defecto, de lo contrario, esto podría ser mucho más corto y podría haber superado a C y Java. Aunque todavía amo el idioma

(λ(x)(if(> x 9)(-(*(+(modulo x 9)1)(expt 10(floor(/ x 9))))1)(+ x 9)))

Hexagonía , 40 31 30 bytes

<_:->.(.+><.'!.\@"9!%>!/{.}|.?

O, si prefiere que su código sea un poco menos lineal y un poco más poligonal:

    < _ : -
   > . ( . +
  > < . ' ! .
 \ @ " 9 ! % >
  ! / { . } |
   . ? . . .
    . . . .

Pruébalo en línea!

Gracias a @FryAmTheEggman por algunas ideas e inspiración: o)

Versión previa: <.:->+_.!(..'!.\><9!%>@.{.}|.?"

Versión anterior: <><.-_|@"'!{|(.9+!8=@>{/".'/:!?$.%\1$..\

Perl 6 ,  38   29 bytes

{$_>9??(1+$_%9)*10**Int($_/9)-1!!$_+9}
{first *.comb.sum==$_,$_^..*}

_{^{(aparentemente el enfoque directo es más corto)}}

Explicación:

{
  first
    *.comb.sum == $_, # lambda that does the check
    $_ ^.. *          # Range.new: $_, Inf, :excludes-min
}

Prueba:

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
   2 => 11,
   8 => 17,
   9 => 18,
  12 => 39,
  16 => 79,
  18 => 99,
  24 => 699,
  32 => 5999,
);

plan +@tests;

my &next-digital-sum = {first *.comb.sum==$_,$_^..*}

for @tests -> $_ ( :key($input), :value($expected) ) {
  is next-digital-sum($input), $expected, .gist;
}

1..8
ok 1 - 2 => 11
ok 2 - 8 => 17
ok 3 - 9 => 18
ok 4 - 12 => 39
ok 5 - 16 => 79
ok 6 - 18 => 99
ok 7 - 24 => 699
ok 8 - 32 => 5999

Java 10, 114 62 bytes

n->{var r="";for(int i=0;i++<n/9;r+=9);return(n>9?n%9:n+9)+r;}

Pruébalo en línea.

EDITAR: 130 73 bytes sin ceros a la izquierda (Gracias a @ levanth` ):

n->{var r="";for(int i=0;i++<n/9;r+=9);return new Long((n>9?n%9:n+9)+r);}

Pruébalo en línea.

Explicación:

n->                           // Method with integer parameter and long return-type
  var r="";                   //  Result-String, starting empty
  for(int i=0;i++<n/9;r+=9);  //  Append `n` integer-divided by 9 amount of 9's to `r`
  return new Long(            //  Cast String to number to remove any leading zeroes:
    (n>9?                     //   If the input `n` is 10 or larger
      n%9                     //    Use `n` modulo-9
     :                        //   Else (`n` is smaller than 10):
      n+9)                    //    Use `n+9`
    +r);}                     //   And append `r`

Rubí, 33 bytes

Esta es una versión aritmética int que resulta ser la misma que la respuesta python de xnor. Es una función anónima que toma y devuelve un int.

->n{n<10?n+9:(1+n%9)*10**(n/9)-1}

MathGolf , 8 7 bytes

Æ)_Σk=▼

Pruébalo en línea!

Entrada implícita yay.

Explicación:

          Implicit input
 Æ     ▼  Do while false loop that pops the condition
  )       Increment top of stack
   _      Duplicate
    Σ     Get the digit sum
     k    Get input
      =   Is equal?
          Implicit output

Rubí, 38 bytes.

f=->n{n<11?n+9:"#{n<19?n-9:f.(n-9)}9"}

Esta respuesta devuelve una cadena o int dependiendo del tamaño de entrada. Es una solución recursiva que pide una solución por 9 menos y luego agrega un "9" al final.

Ruby, 39 bytes

f=->n{n<11?n+9:(n<19?n-9:f.(n-9))*10+9}

Para un byte más, esta respuesta siempre devuelve un int. mismo algoritmo que el anterior pero con números.

C, 80 bytes

i;s;g(j){s=0;for(;j;j/=10)s+=j%10;return s;}f(n){i=n;while(n-g(i))i++;return i;}

Intente sin golf en línea

int g(int j)
{
    int s=0;
    for(;j;j/=10) s += j%10;
    return s;
}

int f(int n)
{
    int i=n;
    for(;n-g(i);i++);
    return i;
}

PHP, 77 caracteres

$n=$argv[1];$m=$n+1;while(1){if(array_sum(str_split($m))==$n)die("$m");$m++;}

Oracle SQL 11.2, 165 bytes

SELECT l FROM(SELECT LEVEL l,TO_NUMBER(XMLQUERY(REGEXP_REPLACE(LEVEL,'(\d)','+\1')RETURNING CONTENT)) s FROM DUAL CONNECT BY 1=1)WHERE s=:1 AND l!=s AND rownum=1;

Sin golf

SELECT l   
FROM   (
         SELECT LEVEL l, -- Number to evaluate
                XMLQUERY( 
                          REGEXP_REPLACE(LEVEL,'(\d)','+\1')  -- Add a + in front of each digit 
                          RETURNING CONTENT
                        ).GETNUMBERVAL()s                     -- Evaluate le expression generated by the added + 
                FROM DUAL 
                CONNECT BY 1=1 -- Run forever            
       )
WHERE s=:1      -- The sum must be equal to the input
  AND l!=s      -- The sum must not be the input 
  AND rownum=1  -- Keep only the first result

Python 3 55 Bytes

Toma dos argumentos que son iguales

f=lambda a,b:a if sum(map(int,str(a)))==b else f(-~a,b)

es decir, para llamarlo usarías f (x, x)

Japt , 9 bytes

@¶Xìx}aUÄ

Intentalo

Powershell, 54 bytes

$args|%{(($_+9),+(''+$_%9+'9'*(($_-$_%9)/9)))[$_-gt9]}

Script de prueba:

$f = {

$args|%{(($_+9),+(''+$_%9+'9'*(($_-$_%9)/9)))[$_-gt9]}

}

@(
    ,(  1,  10   )
    ,(  2 , 11   )
    ,(  8 , 17   )
    ,(  9 , 18   )
    ,( 10,  19   )
    ,( 11,  29   )
    ,( 12 , 39   )
    ,( 16 , 79   )
    ,( 18 , 99   )
    ,( 19 , 199  )
    ,( 24 , 699  )
    ,( 27 , 999  )
    ,( 32 , 5999 )
    ,( 52 , 799999 )
    ,( 128, 299999999999999 )
) | % {
    $a,$e = $_
    $r = &$f $a
    "$($r-eq$e): $r"
}

Salida:

True: 1 : 10
True: 2 : 11
True: 8 : 17
True: 9 : 18
True: 10 : 19
True: 11 : 29
True: 12 : 39
True: 16 : 79
True: 18 : 99
True: 19 : 199
True: 24 : 699
True: 27 : 999
True: 32 : 5999
True: 52 : 799999
True: 128 : 299999999999999

Expansión

• if [$_-gt9]devuelve un primer dígito y una cola
  • un primer dígito es la diferencia entre $ _ y la suma de 9 ( $_%9)
  • una cola son unos pocos nueves '9'*(($_-$_%9)/9))
  • finalmente, convierte una cadena de resultados en un número para eliminar el 0 inicial
• otra cosa vuelve ($_+9)