Envisagez de prendre un nombre entier non négatif tel que 8675309 et de calculer les valeurs absolues des différences entre toutes les paires de chiffres voisins.

Pour que 8675309nous obtenons |8-6| = 2, |6-7| = 1, |7-5| = 2, |5-3| = 2, |3-0| = 3, |0-9| = 9. Corder ces résultats donne en même temps une autre, plus petit entier non négatif: 212239. La répétition du processus donne 11016donc 0115ce qui, par la convention que les zéros non majuscules ne sont pas écrits, simplifie 115ce qui devient , ce qui devient 04ou 4ne peut pas être réduit davantage. En résumé, nous obtenons toutes ces valeurs 8675309 + 212239 + 11016 + 115 + 4 = 8898683.

Définissons la somme des différences de chiffres (ou DDS) comme cette opération consistant à prendre de manière répétée les différences de chiffres d'un nombre pour former un nouveau nombre, puis à ajouter tous les nombres résultants à l'original.

Voici les 20 premières valeurs de la séquence DDS correspondante:

N   DDS(N)
0   0
1   1
2   2
3   3
4   4
5   5
6   6
7   7
8   8
9   9
10  11
11  11
12  13
13  15
14  17
15  19
16  21
17  23
18  25
19  27

Voici les 10000 premières valeurs , dont le graphique est assez curieux:

D'autant plus que son aspect est identique lorsque vous le tracez à 1000 voire à 100:

(J'appellerais ça l' escalier du dentiste ...)

Défi

Ecrivez un programme ou une fonction qui prend un entier non négatif et affiche ou renvoie sa valeur DDS. Par exemple, si l'entrée était 8675309, la sortie devrait l'être 8898683.

Le code le plus court en octets gagne.

Pyth, 17

s.ui.aM-VJjNTtJTQ

Essayez-le ici ou lancez la suite de tests

Explication:

s.u            Q   # Cumulative reduce, i.e. getting the intermediate values of each reduce
                     step and returning them as a list, then sum the list
   i ... T         # Convert the resulting list of numbers into a base 10 number
   .aM             # Get the absolute value of each element of ...
      -VJjNTtJ     # Perform vector subtraction on the lists given by
        JjNT       # assign J the number we currently have converted to its base 10 digits
            tJ     # and J[1:]. e.x. for 123 we get J = [1,2,3] then we do
                   # zip(J,J[1:]) which gives [[1,2],[2,3]] then element wise subtract
                   # to get [-1, -1]

Python 2, 73

Heureusement, j'ai réussi à éviter toute opération de chaîne.

t=lambda n:n>9and abs(n%10-n/10%10)+10*t(n/10)
g=lambda n:n and n+g(t(n))

g est la fonction qui calcule la réponse.

Matlab, 101 à 105 octets

Merci beaucoup à @beaker pour sa suggestion d'utiliser polyvalplutôt si base2dec. Cela m'a permis de

• économiser 4 octets;
• simplifie grandement la généralisation sur une base arbitraire (voir ci-dessous) et économise 22 octets dans cette base; et surtout
• m'a aidé à comprendre que le code du cas général était faux (les zéros non significatifs n'étaient pas supprimés). Le code et les graphiques sont corrects maintenant.

Code:

function y=f(y)
x=+num2str(y);while numel(x)>1
x=polyval(abs(diff(x)),10);y=y+x;x=+dec2base(x,10);end

Exemple:

>> f(8675309)
ans =
     8898683

Bonus: base arbitraire

Une petite généralisation permet d'utiliser une base de nombres arbitraires, pas nécessairement décimale:

• Base arbitraire de 2 à 10, 108 104 octets

  function y=f(y,b)
  x=+dec2base(y,b);while numel(x)>1
  x=polyval(abs(diff(x)),b);y=y+x;x=+dec2base(x,b);end
  

  La raison pour laquelle cela ne fonctionne que pour la base jusqu'à 10est que Matlab dec2basefonction utilise les chiffres 0, 1..., 9, A, B, ..., et il y a un saut dans les codes de caractères (ASCII) de9 de A.

• Base arbitraire de 2 à 36, 124 146 octets

  Le saut de 9à Amentionné ci-dessus nécessite un traitement spécial. La base maximale correspond 36à la dec2basefonction de Matlab .

  function y=f(y,b)
  x=+dec2base(y,b);x(x>57)=x(x>57)-7;while numel(x)>1
  x=abs(diff(x));x=x(find(x,1):end);y=y+polyval(x,b);end
  

Voici comment les escaliers du dentiste recherchent différentes bases:

CJam, 22 21 octets

ri_{\s2ew::-:zsi_@+}h

Notez que ce programme se ferme avec une erreur, qui est autorisée par défaut .

Avec l'interpréteur Java, vous pouvez supprimer les erreurs en fermant STDERR. Si vous essayez ce code en ligne dans l' interpréteur CJam , ignorez toutes les sorties avant la dernière ligne.

Merci à @ Sp3000 d'avoir signalé une erreur dans la révision d'origine.

Merci à @ MartinBüttner pour le golf d'un octet.

Exemple d'exécution

$ cjam digit-difference.cjam 2>&- <<< 8675309     
8898683

Comment ça marche

ri_   e# Read an integer (I) from STDIN and push a copy (A).
{     e# Do:
  \   e#   Swap I on top of A.
  s   e#   Cast I to string.
      e#   For example, 123 -> "123".
  2ew e#   Push the overlapping slices of length 2 (pair of adjacent digits).
  ::- e#   Replace each pair by its difference.
  :z  e#   Apply absolute value to each difference.
  si  e#   Cast to string, then to integer. This is the new I.
      e#   For example, [1 2 3] -> "123" -> 123.
  _   e#   Push a copy of I.
  @   e#   Rotate A on top of the copy of I.
  +   e#   Add I to A, updating A.
}h    e# While A is truthy, repeat the loop.

A sera toujours la vérité quand vérifié par h. Cependant, une fois que I est un entier à un chiffre, 2ewéchouera avec une erreur après avoir consommé le tableau sur lequel il était appelé. Cela ne laisse que le résultat souhaité sur la pile, qui est imprimée avant de quitter.

Labyrinthe , 176 134 127 119 103 97 88 88 82 79 76 72 octets

Merci à Sp3000 d’avoir économisé 1 octet et ouvert la voie à 2 autres.

Cela pourrait probablement encore être raccourci, mais bon, ça bat Java Matlab Python ...

?
_
)/:}+{:`};!
9       "
_ :}-"" :_10
;;{: `" "  :
  {  (_:/=%}
  0+;`"

Essayez-le en ligne.

Cela se termine par une erreur mais le message d'erreur est écrit dans STDERR (c'est pourquoi vous ne le voyez pas dans TIO).

La mise en œuvre est assez simple. Nous ajoutons la valeur actuelle à un total cumulé. Si la valeur actuelle était supérieure à 9, nous calculons ses chiffres en base 10 (via répétition de div-mod) et formons un nouveau nombre à partir des différences absolues. Si nous arrivons à 9ou moins, nous imprimons le total cumulé.

Les chiffres du numéro actuel sont collectés sur la pile auxiliaire avec le chiffre le plus significatif en haut.

Eh bien, la mise en œuvre sophistiquée abs(...)que j'avais ici s'est révélée ridiculement compliquée par rapport à la nouvelle solution ... J'ajouterai une explication mise à jour lorsque j'aurai fini de jouer au golf plus loin.

Java - 300 octets

Version Golfée

static Long t=new Scanner(System.in).nextLong();static char[]c=t.toString().toCharArray();public static void main(String[]z){while(c.length>1)s();System.out.print(t);}static void s(){String s="";for(int i=0;i<c.length-1;)s+=Math.abs(c[i]-c[++i]);Long a=new Long(s);t+=a;c=a.toString().toCharArray();}

Ungolfed / version complète

import java.util.Scanner;

public class DigitDifference {

    static Long t = new Scanner(System.in).nextLong();
    static char[] c = t.toString().toCharArray();

    public static void main(String[] args){
        while( c.length > 1 )
            s();
        System.out.print(t);
    }

    static void s(){
        String s="";
        for(int i = 0; i < c.length-1;)
            s += Math.abs(c[i]-c[++i]);
        Long a = new Long(s);
        t += a;
        c = a.toString().toCharArray();
    }
}

Julia, 81 60 octets

n->(s=n;while n>9 s+=n=int(join(abs(diff(["$n"...]))))end;s)

Ungolfed:

function f(n::Int)
    # Initialize a sum to the input
    s = n

    while n > 9
        # Get absolute values of the pairwise differences of the
        # digits of n, join as a string, convert it to an integer,
        # and reassign n
        n = int(join(abs(diff(["$n"...]))))

        # ["$n"...] actually splits n as a string into a vector
        # of its characters, but the difference between ASCII
        # codes is the same as the difference between the numbers
        # so it works as expected

        # Add the new n to the running sum
        s += n
    end

    # Return the sum
    return s
end

Essayez-le en ligne

Sauvé 21 octets grâce à Feersum et Glen O!

OK , 37 32 24 23 octets

+/(10/{%x*x}1_-':.:'$)\

En action:

  +/(10/{%x*x}1_-':.:'$)\8675309
8898683

  (+/(10/{%x*x}1_-':.:'$)\)'!20
0 1 2 3 4 5 6 7 8 9 11 11 13 15 17 19 21 23 25 27

K5 a quelques fonctionnalités bien adaptées à cela - "encoder" et "décoder" peuvent effectuer une conversion de base, chaque paire ( ':) couple des éléments séquentiels dans une liste et un balayage en point fixe ( \) peut produire la séquence itérée jusqu'à ce qu'elle s'arrête en changeant. L'absence d'un primitif abs()conduit à un certain volume disgracieux sous la forme de {(x;-x)x<0}', cependant.

Modifier:

Au lieu de {(x;-x)x<0}', je peux (un peu gaspillage) prendre la racine carrée du carré de la séquence ( {%x*x}en économisant 5 octets.

Edit 2:

Inspiré par la solution APL de @maurinus, je peux remplacer le "décodage" ( ((#$x)#10)\x) en évaluant chaque caractère de la représentation sous forme de chaîne du nombre- .:'$x! Cela me permet également d'utiliser une forme tacite de l'expression entière, en enregistrant des caractères supplémentaires.

Python 2, 87 octets

f=lambda n:n and n+f(int('0'+''.join(`abs(int(a)-int(b))`for a,b in zip(`n`,`n`[1:]))))

Ajoute récursivement le nombre actuel et prend les différences de chiffres. Beaucoup de conversion entre les nombres et les chaînes. Peut probablement être amélioré.

Julia, 55 48 octets

h=n->(n>9&&h(int(join(abs(diff(["$n"...]))))))+n

Ungolfed:

function h(n)
  if n>9
    # If multiple digits, find the digit difference...
    digitdiff=int(join(abs(diff(["$n"...]))))
    # ... recurse the function...
    downsum=h(digitdiff)
    # ... and return the sum so far (working up from the bottom)
    return downsum+n
  else
    # If single digit, no further recursion, return the current number
    return n
  end
end

Cela revient essentiellement au niveau à un chiffre (où aucune différence de chiffre ne peut être effectuée), puis la somme est rétablie à la sortie de la récursion, niveau par niveau.

Haskell, 140 octets

d Fait le travail.

import Data.Char
d n=sum.m(read.m intToDigit).fst.span(/=[]).iterate s.m digitToInt.show$n
s l@(h:t)=snd$span(==0)$m abs$zipWith(-)l t
m=map

Est-ce que quelqu'un sait comment éviter d'importer les fonctions de conversion longues?

K5, 50 octets

+/{(r;x)@~r:.,/"0",{$(0;-r;r)@(~^r)+0<r:x-y}':$x}\

APL (22)

{⍵≤9:⍵⋄⍵+∇10⊥|2-/⍎¨⍕⍵}

Explication:

• ⍵≤9:⍵: si ⍵ ≤ 9, retourne inchangé.
• ⍎¨⍕⍵: convertir en chaîne, puis évaluer chaque caractère
• 2-/: soustrayez tous les deux nombres adjacents
• |: prendre les valeurs absolues
• 10⊥: transformer le tableau en un nombre base 10
• ⍵+∇: appelle la fonction récursivement avec cette nouvelle valeur et ajoute le résultat à l'entrée

Mathematica, 72 69 65 octets

Tr@FixedPointList[FromDigits@*Abs@*Differences@*IntegerDigits,#]&

Je suis ouvert aux suggestions ici.

JavaScript ES6, 73 octets

t=n=>(b=10,M=Math).ceil(n&&n+t((j=n=>n>9&&M.abs(n%b-n/b%b)+b*j(n/b))(n)))

Cela ne va pas être plus court: / Je vais essayer plus d'approches mais c'est la plus courte jusqu'à présent

JavaScript (ES6), 69

Testez l’exécution de l’extrait de code ci-dessous dans un navigateur compatible EcmaScript 6 (mais pas avec Chrome, car il ne prend toujours pas en charge l’opérateur de diffusion ...). MS Edge peut-être?

f=n=>n&&(n+=r='',[...n].map(d=>(r+=d>p?d-p:p-d,p=d),p=n[0]),+n+f(+r))

function test()
{
  var i=+I.value
  O.innerHTML = i+' -> '+f(i) + '\n' + O.innerHTML 
}

<input id=I value=8675309><button onclick=test()>-></button>
<pre id=O></pre>

Alternative, utilisant une compréhension de matrice qui est maintenant ciblée EcmaScript 2016 (ES7), 67 octets:

f=n=>n&&(n+=r='',p=n[0],[for(d of n)(r+=d>p?d-p:p-d,p=d)],+n+f(+r))

Python 3, 125 octets

J'aimais la brièveté de regex jusqu'à ce que j'essaye de l'utiliser pour ce défi ... re.findall('\d\d',s,overlapped=True)n'est pas allumé;)

s=input()
p=int
x=p(s)
while p(s)>9:g=str(s);s=p(''.join(str(abs(p(g[i])-p(g[i+1])))for i in range(len(g)-1)));x+=s 
print(x)

Salutations @Todd :)

J, 70 octets

 +/([:10&#.[:(2|@:-/\])[:10&(]#:~[#~[:>.[^.])])`]@.(11&>)^:a:".(1!:1)3

C 162 octets

joué au golf:

main(int argc,char **argv){char *c=argv[1];int u=atoi(c),d;do{while(c[1]!=0){*c=abs(*c-*(c+1))+48;c++;}*c=0;c=argv[1];d=atoi(c);u+=d;}while(d>9);printf("%d",u);}

ungolfed:

main(int argc, char **argv)
{
    char *c=argv[1];
    int u=atoi(c),d;

    do
    {
        while(c[1]!=0)
        {
            *c=abs(*c-*(c+1))+48;
            c++;
        }

        *c=0;
        c=argv[1];
        d=atoi(c);
        u+=d;
    }
    while(d>9);

    printf("%d\n",u);
}

R, 134 octets

Code

f=function(x){z=x;while(z>9){n=seq(nchar(z));z=abs(diff(strtoi(substring(z,n,n))));z=sum(z*10**(rev(seq(length(z)))-1));x=x+z};cat(k)}

Testez-le en ligne .

Ungolfed

f=function(x){
  z=x;
  while(z>9){
    n=seq(nchar(z));
    z=abs(diff(strtoi(substring(z,n,n))));
    z=sum(z*10**(rev(seq(length(z)))-1));
    x=x+z
  };
  cat(x)
}

Voici le graphique de la différence de la série "Somme de différence de nombre d'un nombre" de f (1) à f (1m). Juste parce que j'adore les diff.

Code de parcelle

s <- seq(1,100000)
serie <- sapply(s,f)
plot(diff(ts(serie)),xlab="",ylab="")

MATLAB (141)(137)

EDIT: 4 octets en moins, grâce à @Andras

function[s j]=n(T,b,c),if(T/b>9),u=fix(T/10);[x e]=n(T,b*10,0);y=n(u,b,0);[w z]=n(u,b,c);s=abs(x-y);j=s+e+10*c*z;else,s=mod(T,10);j=s;end

• Cela fait mieux que la réponse de @LuisMendo, mais au moins, je pourrais réduire le temps d’exécution, ce que j’aurais simplement essayé de diversifier les moyens de s’attaquer à ce problème.
• Je pourrais le réduire davantage, mais comme je perdais moins de temps, je perdais plus d'octets, voici donc le principe:

Le programme additionne les chiffres de la même ligne avant les chiffres en ligne, cela signifie qu'il a utilisé la division entière "n / 10" log_10 (n) fois uniquement, la complexité est O (N).

Si n= a b c d

a          b           c           d
   |a-b|       |b-c|       |c-d|
    ||a-b|-|b-c|| ||b-c|-|c-d||
   ....

Mon programme calcule:

a+|a-b| + | |a-b|-|b-c| |  +  |  | |a-b|-|b-c| | - | |b-c|-|c-d| |  |
+10*(
b+|b-c| + | |b-c|-|c-d| |
+10*(
c+|c-d|
+10*(
d
)
)
)

Usage:

  [a b]=n(13652,1,1)

a =

1

 b =

   16098

Prolog, 143 octets

Code:

q(X,N):-X<9,N=0;A is abs(X mod 10-X//10 mod 10),Y is X//10,q(Y,M),N is A+M*10.
r(X,N):-X<9,N=X;q(X,Y),r(Y,M),N is X+M.
p(X):-r(X,N),write(N).

A expliqué:

q(X,N):-X<9,N=0;                                                         % If only one digit, the difference is 0
        A is abs(X mod 10-X//10 mod 10),Y is X//10,q(Y,M),N is A+M*10.   % Else, the difference is the difference between the last 2 digits + the recursive difference of the number without the last digit
r(X,N):-X<9,N=X;                                                         % If we only have 1 digit the final answer is that digit
        q(X,Y),r(Y,M),N is X+M.                                          % Else, the final answer is the current number + the recursive difference of that number
p(X):-r(X,N),write(N).         

q effectue les calculs qui convertissent un nombre en différence de chiffres.
r appelle q de manière récursive et récapitule les résultats pour trouver la somme des différences numériques.
p est le point d'entrée. Prend un numéro, appelle r et imprime la réponse.

Exemple:

>p(8675309).
8898683

Essayez-le en ligne ici .

PHP - 198 octets

<?$x=$t=$_GET['V'];function z($x){global$t;for($i=0;$i<strlen($x)-1;$i++){$z=str_split($x);$r.=str_replace('-','',$z[$i]-$z[$i+1]);}$r=ltrim($r,'0');$t+=$r;return strlen($r)>1?z($r):0;}z($x);echo$t;

Ungolfed

<?
$x=$t=$_GET['V']; // Gets the value from input
function z($x){
    global$t;
    for($i=0;$i<strlen($x)-1;$i++){
        $z=str_split($x); //Turns the string into an array
        $r.=str_replace('-','',$z[$i]-$z[$i+1]); // Sums the two values and removes the minus signal
    }
    $r=ltrim($r,'0'); // Remove trailing zeroes
    $t+=$r; // Adds to global var
    return strlen($r)>1?z($r):0; // Checks the size of the string. If >1, calls the function again
}

z($x);
echo$t;

Perl 6 , 56 octets

{[+] $_,{+.comb.rotor(2=>-1)».map((*-*).abs).join}…0} # 56 bytes

usage:

my &code = {...} # insert code from above

(180..190).map: &code;
# (259 258 259 260 261 262 263 264 265 266 280)

say code 8675309; # 8898683