Nehmen Sie eine nicht negative Ganzzahl wie 8675309 und berechnen Sie die absoluten Werte der Differenzen zwischen allen Paaren benachbarter Ziffern.

Für 8675309wir bekommen |8-6| = 2, |6-7| = 1, |7-5| = 2, |5-3| = 2, |3-0| = 3, |0-9| = 9. Diese Ergebnisse zusammen Bespannen liefert eine weitere, kleinere nicht-negative ganze Zahl ist : 212239. Das Wiederholen des Vorgangs ergibt 11016dann 0115, was durch die Konvention, dass führende Nullen nicht geschrieben werden, vereinfacht wird, wie 115, was wird 04oder 4was nicht weiter reduziert werden kann. Wenn wir all diese Werte zusammenfassen, erhalten wir 8675309 + 212239 + 11016 + 115 + 4 = 8898683.

Definieren wir die Zifferndifferenzsumme (DDS) als diesen Vorgang, bei dem die Zifferndifferenzen einer Zahl wiederholt werden, um eine neue Zahl zu bilden, und dann alle resultierenden Zahlen zum Original hinzugefügt werden.

Hier sind die ersten 20 Werte in der entsprechenden DDS-Sequenz:

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

Hier sind die ersten 10000 Werte , für die die Grafik recht merkwürdig ist:

Zumal es beim Plotten auf 1000 oder sogar 100 gleich aussieht:

(Ich würde es die Treppe des Zahnarztes nennen ...)

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine nicht negative Ganzzahl einliest und deren DDS-Wert ausgibt oder zurückgibt. Wenn zum Beispiel die Eingabe war 8675309, sollte die Ausgabe sein 8898683.

Der kürzeste Code in Bytes gewinnt.

Pyth, 17

s.ui.aM-VJjNTtJTQ

Probieren Sie es hier aus oder starten Sie die Test Suite

Erläuterung:

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

Zum Glück habe ich es geschafft, String-Operationen zu vermeiden.

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 ist die Funktion, die die Antwort berechnet.

Matlab, 101 105 Bytes

Vielen Dank an @beaker für seinen Vorschlag, polyvalstattdessen if zu verwenden base2dec. Das hat mir erlaubt

• 4 Bytes speichern;
• Vereinfachen Sie die Verallgemeinerung auf eine beliebige Basis (siehe unten) erheblich und sparen Sie dort 22 Bytes. und vorallem,
• half mir zu erkennen, dass der Code für den allgemeinen Fall falsch war (führende Nullen wurden nicht entfernt). Der Code und die Grafiken sind jetzt korrekt.

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

Beispiel:

>> f(8675309)
ans =
     8898683

Bonus: beliebige Basis

Eine kleine Verallgemeinerung erlaubt die Verwendung einer willkürlichen Zahlenbasis, nicht notwendigerweise einer Dezimalzahl:

• Beliebige Basis von 2 bis 10, 108 104 Bytes

  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
  

  Der Grund , warum dies nur für die Basis arbeitet bis zu 10ist , dass Matlab - dec2baseFunktion verwendet Ziffern 0, 1, ..., 9, A, B, ..., und es gibt einen Sprung in Zeichen (ASCII - Codes) aus 9zu A.

• Beliebige Basis von 2 bis 36, 124 146 Bytes

  Der Sprung von 9bis Azu über Bedürfnissen spezielle Behandlung im Sinne. Die maximale Basis entspricht der 36Matlab- dec2baseFunktion.

  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
  

So sehen die Treppen des Zahnarztes für verschiedene Basen aus:

CJam, 22 21 Bytes

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

Beachten Sie, dass dieses Programm mit einem Fehler beendet wird, der standardmäßig zulässig ist .

Mit dem Java-Interpreter können Fehler durch Schließen von STDERR unterdrückt werden. Wenn Sie diesen Code online im CJam-Interpreter ausprobieren , ignorieren Sie alle Ausgaben vor der letzten Zeile.

Vielen Dank an @ Sp3000 für den Hinweis auf einen Fehler in der Originalversion.

Vielen Dank an @ MartinBüttner für das Golfen ab 1 Byte.

Beispiellauf

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

Wie es funktioniert

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 wird immer wahr sein, wenn es von überprüft wird h. Sobald ich jedoch eine einstellige Ganzzahl bin , tritt 2ewnach dem Aufrufen des Arrays ein Fehler auf. Dadurch bleibt nur das gewünschte Ergebnis auf dem Stapel, der vor dem Beenden gedruckt wird.

Labyrinth , 176 134 127 119 103 97 88 82 79 76 72 Bytes

Dank an Sp3000 für das Speichern von 1 Byte und das Vorbereiten des Weges für 2 weitere.

Dies könnte wahrscheinlich noch gekürzt werden, aber hey, es schlägt Java Matlab Python ...

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

Probieren Sie es online aus.

Dies wird mit einem Fehler beendet, aber die Fehlermeldung wird in STDERR geschrieben (weshalb Sie sie in TIO nicht sehen).

Die Implementierung ist recht unkompliziert. Wir addieren den aktuellen Wert zu einer laufenden Summe. Wenn der aktuelle Wert größer als war 9, berechnen wir die 10-stelligen Basiswerte (durch wiederholtes div-mod) und bilden aus den absoluten Differenzen eine neue Zahl. Wenn wir zu 9oder weniger kommen, drucken wir die laufende Summe.

Die Ziffern der aktuellen Nummer werden auf dem Zusatzstapel mit der höchstwertigen Ziffer oben gesammelt.

Nun, die originelle Implementierung von abs(...)hier hat sich im Vergleich zur neuen Lösung als lächerlich kompliziert herausgestellt ... Ich werde eine aktualisierte Erklärung hinzufügen, wenn ich mit dem Golfspielen fertig bin.

Java - 300 Bytes

Golf Version

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 / Vollversion

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 Bytes

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

Probieren Sie es online aus

21 Bytes gespart dank feersum und Glen O!

ok , 37 32 24 23 bytes

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

In Aktion:

  +/(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 verfügt über einige Funktionen, die sich gut dafür eignen: "Codieren" und "Decodieren" können eine Basiskonvertierung durchführen, jedes Paar ( ':) paart aufeinanderfolgende Elemente in einer Liste und Festkommaabtastung ( \) kann die iterierte Sequenz bis zum Ende erzeugen Ändern. Das Fehlen eines Primitivs abs()führt jedoch zu einer unschönen Masse in Form von {(x;-x)x<0}'.

Bearbeiten:

Stattdessen {(x;-x)x<0}'kann ich (etwas verschwenderisch) die Quadratwurzel des Quadrats der Sequenz nehmen ( {%x*x}und 5 Bytes sparen).

Bearbeiten 2:

Inspiriert von der APL-Lösung von @maurinus, kann ich das "decode" ( ((#$x)#10)\x) ersetzen, indem ich jedes Zeichen der Zeichenfolgendarstellung der Zahl auswerte - .:'$x! Dadurch kann ich auch eine implizite Form des gesamten Ausdrucks verwenden und zusätzliche Zeichen speichern.

Python 2, 87 Bytes

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

Addiert rekursiv die aktuelle Nummer und nimmt die Ziffernunterschiede auf. Viele Konvertierungen zwischen Zahlen und Zeichenfolgen. Kann wahrscheinlich verbessert werden.

Julia, 55 48 Bytes

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

Im Wesentlichen wird dies auf die einstellige Ebene zurückgeführt (auf der keine Ziffernunterschiede vorgenommen werden können) und dann beim Verlassen der Rekursion Level für Level aufsummiert.

Haskell, 140 Bytes

d macht den Job.

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

Weiß jemand, wie man es vermeidet, die langen Konvertierungsfunktionen zu importieren?

K5, 50 Bytes

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

APL (22)

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

Erläuterung:

• ⍵≤9:⍵: Wenn ⍵ ≤ 9, ⍵ unverändert zurückgeben.
• ⍎¨⍕⍵: konvertiere ⍵ in einen String und bewerte dann jedes Zeichen
• 2-/: subtrahiere jeweils zwei benachbarte Zahlen
• |: nimm die absoluten Werte
• 10⊥: verwandle das Array in eine Basis-10-Zahl
• ⍵+∇: Rufe die Funktion rekursiv mit diesem neuen Wert auf und füge das Ergebnis zur Eingabe hinzu

Mathematica, 72 69 65 Bytes

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

Ich bin offen für Vorschläge hier.

JavaScript ES6, 73 Byte

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

Das wird nicht kürzer: / Ich werde mehr Ansätze ausprobieren, aber dies ist der kürzeste bisher

JavaScript (ES6), 69

Testen Sie das folgende Snippet in einem EcmaScript 6-kompatiblen Browser (aber nicht in Chrome, da der Spread-Operator immer noch nicht unterstützt wird ...). MS Edge vielleicht?

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, bei Verwendung des Array-Verständnisses , das jetzt auf EcmaScript 2016 (ES7) abzielt, 67 Byte:

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 Bytes

Ich mochte die Kürze von Regex, bis ich versuchte, es für diese Herausforderung zu nutzen ... re.findall('\d\d',s,overlapped=True)ist nicht eingeschaltet ;)

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)

Prost @Todd :)

J, 70 Bytes

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

C 162 Bytes

Golf gespielt:

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 Bytes

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

Testen Sie es online .

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

Hier ist die Darstellung der Differenz der Reihe "Zifferndifferenzsumme einer Zahl" von f (1) bis f (1m). Nur weil ich es liebe zu diff.

Plotcode

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

MATLAB (141)(137)

EDIT: 4 Bytes weniger dank @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

• Dies hat @LuisMendos Antwort zwar übertroffen, aber ich könnte zumindest die Ausführungszeit verkürzen, was ich nur versucht hätte, die Möglichkeiten zur Lösung dieses Problems zu diversifizieren.
• Ich könnte es mehr reduzieren, aber da ich weniger Zeit habe, verschwende ich mehr Bytes, also hier ist das Prinzip:

Das Programm summiert Ziffern derselben Zeile vor inline Ziffern. Dies bedeutet, dass es nur die Ganzzahldivision "n / 10" log_10 (n) mal verwendet hat, die Komplexität ist O (N).

Wenn n= a b c d

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

Mein Programm berechnet:

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

Verwendungszweck:

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

a =

1

 b =

   16098

Prolog, 143 Bytes

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

Erklärt:

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 führt die Berechnungen durch, die eine Zahl in ihre Zifferndifferenz umwandeln.
r ruft rekursiv q auf und summiert die Ergebnisse, um die Zifferndifferenzsumme zu finden.
p ist der Einstiegspunkt. Nimmt eine Nummer, ruft r an und druckt die Antwort.

Beispiel:

>p(8675309).
8898683

Probieren Sie es hier online aus .

PHP - 198 Bytes

<?$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 Bytes

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

Verwendungszweck:

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