"Somme numérique" fait référence à la somme de tous les chiffres d'un nombre.

Par exemple, la somme numérique de 1324est 10, car 1+3+2+4 = 10.

Le défi est d'écrire un programme / une fonction pour calculer le plus petit nombre plus grand que l'entrée dont la somme numérique est l'entrée.

Exemple avec procédure pas à pas

Par exemple, prenez le nombre 9en entrée:

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

La sortie valide serait le plus petit nombre ci-dessus, qui est 18.

Spécifications

Notez que ce 9n'est pas la sortie valide pour cet exemple, car le nombre inversé doit être supérieur au nombre d'origine.

Notez que l'entrée sera positive.

Cas de test:

 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)

Les références:

Il s'agit d' OEIS A161561 .

Edit: Ajout d'un testcase supplémentaire (18)

Merci à Martin Ender pour l' extrait de classement

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 octets

Code:

[>DSO¹Q#

Expliqué:

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

Essayez-le en ligne

Edit: 9 octets enregistrés grâce à @Adnan

Python 2, 33 octets

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

Une expression directe. Fait une chaîne de nombres avec 9 à la fin et le reste au début. Sauf, pour un chiffre n, donne n+9.

Certaines sorties ont des zéros non significatifs ( 099pour 18).

Rétine , 39 31 octets

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

Prend entrée en unaire .

Essayez-le en ligne! (Les deux premières lignes permettent d'exécuter plusieurs cas de test à la fois et convertissent de décimal en unaire pour plus de commodité.)

Cela ne recherche pas réellement le résultat de façon linéaire, mais le calcule explicitement:

• Si l'entrée nest supérieure à 9, nous la remplaçons n % 9par des n / 9neuf (au sol).
• Sinon, nous le remplaçons par n + 9.

En utilisant !(ou toute autre chose qui ne l'est pas 1) comme chiffre unaire, je peux enregistrer un octet de plus avec l'approche suivante:

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

Mais ce format d'entrée est un peu exagéré, je pense.

Pyth , 8 octets

fqQsjT;h

Suite de tests.

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 octets

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

Fait à peu près la même chose que la plupart des autres réponses ici. Je voulais montrer l'approche Java sans utiliser de manipulation de chaîne ni de boucles.

Merci à FryAmTheEggman de me rappeler que je suis stupide;)

MATL , 10 9 octets

`QtV!UsG-

Essayez-le en ligne!

Explication

`        % 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 octets

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

38 octets comme ES6:

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

Python 3, 128 94 84 74 octets

Sans sortie, approche directe, golfeur débutant;)

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

En fait, 17 octets

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

Essayez-le en ligne!

Explication:

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

Une macro avec une fonction d'assistance.

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

La efonction calcule simplement des puissances de dix, et la Fmacro utilise la même méthode de résolution que ce rubis et cette réponse python . malheureusement, il est plus long que la même longueur que ces deux réponses réunies. Mais c'est la première réponse C.

(8 octets enregistrés par l'astuce de suppression de Lynn int.)

Brachylog , 8 octets (non concurrent)

<.=:ef+?

= a été modifié après la publication de ce défi, de sorte qu'il fonctionne désormais sur des domaines éventuellement infinis, ce qui est le cas ici.

Explication

<.       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

Cela fera marche arrière = jusqu'à ce que la valeur de Output rende ce prédicat entier vrai.

TSQL (sqlserver 2012), 107 99 octets

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

Essayez-le en ligne!

Python 2, 39 octets

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

Arithmétique entière pure.

Programme complet avec sortie

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

Sortie:

11
17
39
79
89
99
699
5999

PowerShell v2 +, 62 octets

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

Prend l'entrée $npuis exécute une forboucle. Nous initialisons la boucle en définissant notre numéro cible,, $apour être un plus grand que $n(car il doit être plus grand, et cela garantit un 1..9fonctionnement correct). Chaque boucle est incrémentée $a++. Rien ne se passe dans la boucle proprement dite, mais le conditionnel est l'endroit où la logique du programme se produit. Nous prenons littéralement le nombre cible sous la forme d'une chaîne, le convertissons en un tableau de caractères, -joining le tableau avec +, puis le redirige vers iex(similaire à eval). Nous testons si c'est égal à notre nombre d'entrée ou non, et continuons à boucler en conséquence. Une fois que nous avons quitté la boucle, nous avons atteint où notre numéro cible est une somme numérique égale à notre numéro d'entrée, il $aest donc placé sur le pipeline et la sortie est implicite.

Pour référence, voici la méthode "construire une chaîne avec le nombre approprié de 9" que d'autres ont fait, à 67 octets

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

ou la méthode "arithmétique d'entier pur" que d'autres ont fait, à 70 octets

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

Aucun des deux n'est plus court, mais les deux sont plus intéressants.

Pyke, 9 8 7 octets, non concurrent - utilise une version plus récente

.fhsq)h

Essayez-le ici!

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

JavaScript (ES2015), 45 39 33 octets

Sauvegardé encore 6 octets grâce à @Conor O'Brien et @Shaun H.
Je pense que je vais le laisser tel quel, car cette version diffère de la réponse de @ Neil en utilisant String.repeat().

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

Version précédente (sauvé 6 octets grâce à @Qwertiy):

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

Première version:

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

Lua, 52 octets

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

Destiné à être enregistré dans un fichier et exécuté avec l'interpréteur Lua, par exemple lua <file> <input number>

Vous pouvez également l'essayer ici: https://repl.it/CXom/1

(Sur repl.it, le numéro d'entrée est codé en dur pour faciliter les tests)

Raquette 70 caractères, 71 octets

Même algorithme que la plupart des autres. Assez triste de ne pas avoir% pour modulo, ou ** pour expt, ou une division entière par défaut, sinon cela pourrait être beaucoup plus court et j'aurais pu dépasser C et Java. J'adore toujours la langue

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

Hexagonie , 40 31 30 octets

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

Ou, si vous préférez que votre code soit un peu moins linéaire et un peu plus polygonal:

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

Essayez-le en ligne!

Merci à @FryAmTheEggman pour quelques idées et inspiration: o)

La version précédente: <.:->+_.!(..'!.\><9!%>@.{.}|.?"

Version précédente: <><.-_|@"'!{|(.9+!8=@>{/".'/:!?$.%\1$..\

Perl 6 ,  38   29 octets

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

_{^{(apparemment l'approche directe est plus courte)}}

Explication:

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

Tester:

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

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

Essayez-le en ligne.

EDIT: 130 73 octets sans zéros non significatifs (Merci à @ levanth` ):

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

Essayez-le en ligne.

Explication:

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`

Rubis, 33 octets

Il s'agit d'une version arithmétique int qui se trouve être identique à la réponse python de xnor. C'est une fonction anonyme qui prend et retourne un int.

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

MathGolf , 8 7 octets

Æ)_Σk=▼

Essayez-le en ligne!

Entrée implicite oui.

Explication:

          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

Rubis, 38 octets

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

Cette réponse renvoie une chaîne ou un entier selon la taille d'entrée. C'est une solution récursive qui demande une solution pour 9 de moins puis ajoute un "9" à la fin.

Rubis, 39 octets

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

Pour un octet de plus, cette réponse renvoie toujours un entier. même algorithme que ci-dessus mais avec des nombres.

C, 80 octets

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

Essai non golfé en ligne

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 caractères

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

Oracle SQL 11.2, 165 octets

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;

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

Prend deux arguments identiques

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

c'est-à-dire que pour l'appeler, vous utiliseriez f (x, x)

Japt , 9 octets

@¶Xìx}aUÄ

Essayez-le

Powershell, 54 octets

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

Script de test:

$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"
}

Sortie:

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

Expalantion

• si [$_-gt9] renvoie un premier chiffre et une queue
  • un premier chiffre est la différence entre $ _ et la somme de 9 ($_%9 )
  • une queue fait quelques neuf - '9'*(($_-$_%9)/9))
  • enfin, convertit une chaîne de résultat en nombre pour supprimer le 0 en tête
• sinon retourne ($_+9)