Zastanów się nad wzięciem nieujemnej liczby całkowitej, takiej jak 8675309 i obliczeniem wartości bezwzględnych różnic między wszystkimi parami sąsiednich cyfr.

Dla 8675309mamy |8-6| = 2, |6-7| = 1, |7-5| = 2, |5-3| = 2, |3-0| = 3, |0-9| = 9. Sznurka wyniki te razem daje inny, mniejszy nieujemną liczbę całkowitą: 212239. Powtórzenie tego procesu daje 11016zatem 0115, że zgodnie z konwencją, że wiodące zera nie są zapisywane, upraszcza as 115, który staje się 04lub 4którego nie można już dalej zmniejszać. Podsumowując wszystkie te wartości, otrzymujemy 8675309 + 212239 + 11016 + 115 + 4 = 8898683.

Zdefiniujmy różnicę cyfr różnicowych (lub DDS) jako tę operację polegającą na wielokrotnym przyjmowaniu różnic liczbowych liczby w celu utworzenia nowej liczby, a następnie dodawaniu wszystkich uzyskanych liczb do oryginału.

Oto pierwsze 20 wartości w odpowiedniej sekwencji DDS:

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

Oto pierwsze 10000 wartości , których wykres jest dość ciekawy:

Zwłaszcza, że ​​wygląda tak samo, gdy wydrukujesz go na 1000, a nawet 100:

(Nazwałbym to schodami dentysty ...)

Wyzwanie

Napisz program lub funkcję, która przyjmuje nieujemną liczbę całkowitą i drukuje lub zwraca jej wartość DDS. Na przykład, jeśli wejście było 8675309, wyjście powinno być 8898683.

Najkrótszy kod w bajtach wygrywa.

Pyth, 17 lat

s.ui.aM-VJjNTtJTQ

Wypróbuj tutaj lub uruchom pakiet testowy

Wyjaśnienie:

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

Na szczęście udało mi się uniknąć jakichkolwiek operacji na łańcuchach.

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 to funkcja, która oblicza odpowiedź.

Matlab, 101 105 bajtów

Bardzo dziękuję @beaker za jego sugestię użycia polyvalzamiast tego base2dec. To mi pozwoliło

• zapisz 4 bajty;
• znacznie uprościć generalizację do dowolnej bazy (patrz poniżej) i zapisać tam 22 bajty; i przede wszystkim,
• pomógł mi zrozumieć, że kod dla ogólnej sprawy był niepoprawny (początkowe zera nie były usuwane). Kod i wykresy są teraz poprawne.

Kod:

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

Przykład:

>> f(8675309)
ans =
     8898683

Bonus: dowolna podstawa

Niewielkie uogólnienie pozwala na użycie dowolnej liczby liczbowej, niekoniecznie dziesiętnej:

• Podstawa arbitralna od 2 do 10, 108 104 bajtów

  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
  

  Powodem, dlaczego to działa tylko na bazie maksymalnie 10jest to, że MATLAB jest dec2baseużycie funkcji cyfry 0, 1, ..., 9, A, B, ..., a tam skok znaków (ASCII) kody od 9do A.

• Podstawa arbitralna od 2 do 36, 124 146 bajtów

  Skok ze 9do Aktórej mowa powyżej wymaga specjalnego traktowania. Maksymalna podstawa jest 36zgodna z dec2basefunkcją Matlaba .

  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
  

W ten sposób schody dentysty szukają różnych podstaw:

CJam, 22 21 bajtów

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

Pamiętaj, że ten program kończy działanie z błędem, który jest domyślnie dozwolony .

Za pomocą interpretera Java błędy można stłumić, zamykając STDERR. Jeśli wypróbujesz ten kod online w interpretatorze CJam , zignoruj ​​wszystkie dane wyjściowe przed ostatnim wierszem.

Dzięki @ Sp3000 za wskazanie błędu w oryginalnej wersji.

Dzięki @ MartinBüttner za grę w golfa na 1 bajcie.

Przykładowy przebieg

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

Jak to działa

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 zawsze będzie zgodne z prawdą, gdy zostanie sprawdzone przez h. Jednak gdy będę jednocyfrową liczbą całkowitą, 2ewzakończy się niepowodzeniem z błędem po zużyciu tablicy, do której został wywołany. Pozostawia to tylko pożądany wynik na stosie, który jest drukowany przed wyjściem.

Labirynt , 176 134 127 119 103 97 88 82 79 76 72 bajty

Dzięki Sp3000 za oszczędność 1 bajtu i torowanie drogi dla 2 kolejnych.

Prawdopodobnie można to jeszcze skrócić, ale hej, to bije Java Matlab Python ...

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

Wypróbuj online.

To kończy się błędem, ale komunikat o błędzie jest zapisywany w STDERR (dlatego nie widzisz go w TIO).

Wdrożenie jest dość proste. Dodajemy bieżącą wartość do bieżącej sumy. Jeśli bieżąca wartość była większa niż 9, obliczamy jej 10-cyfrowe cyfry (za pomocą powtarzanego div-mod) i tworzymy nową liczbę z różnic bezwzględnych. Jeśli dojdziemy do 9lub mniej, drukujemy bieżącą sumę.

Cyfry bieżącego numeru są gromadzone na stosie pomocniczym, z najbardziej znaczącą cyfrą na górze.

Cóż, fantazyjna implementacja abs(...), którą tu miałem, okazała się absurdalnie skomplikowana w porównaniu do nowego rozwiązania ... Dodam zaktualizowane wyjaśnienie, kiedy skończę grać w golfa.

Java - 300 bajtów

Wersja golfowa

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

Wersja bez golfa / pełna

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 bajtów

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

Nie golfowany:

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

Wypróbuj online

Zaoszczędzono 21 bajtów dzięki feersum i Glen O!

ok , 37 32 24 23 bajtów

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

W akcji:

  +/(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 ma kilka cech, które dobrze do tego nadają - „kodowanie” i „dekodowanie” może przeprowadzać konwersję zasad, każda para ( ':) paruje elementy sekwencyjne na liście, a skanowanie z ustalonym punktem ( \) może tworzyć sekwencję iterowaną aż do zatrzymania wymiana pieniędzy. Jednak brak prymitywu abs()prowadzi do jakiejś nieestetycznej masy w postaci {(x;-x)x<0}'.

Edytować:

Zamiast tego {(x;-x)x<0}'mogę (nieco marnotrawić) wziąć pierwiastek kwadratowy z sekwencji ( {%x*x}oszczędzając 5 bajtów.

Edycja 2:

Zainspirowany rozwiązaniem APL @maurinus, mogę zastąpić „dekodowanie” ( ((#$x)#10)\x) oceną każdego znaku reprezentującego ciąg liczbowy .:'$x! Pozwala mi to również na użycie milczącej formy całego wyrażenia, oszczędzając dodatkowe znaki.

Python 2, 87 bajtów

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

Rekurencyjnie dodaje bieżący numer i przyjmuje różnice cyfr. Dużo konwersji liczb i ciągów. Prawdopodobnie można to poprawić.

Julia, 55 48 bajtów

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

Nie golfowany:

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

Zasadniczo, to powraca do poziomu jednocyfrowego (gdzie nie można wykonać różnicy cyfr), a następnie sumuje się, gdy opuszcza rekurencję, poziom po poziomie.

Haskell, 140 bajtów

d wykonuje pracę.

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

Czy ktoś wie, jak uniknąć importowania długich funkcji konwersji?

K5, 50 bajtów

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

APL (22)

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

Wyjaśnienie:

• ⍵≤9:⍵: jeśli ⍵ ≤ 9, zwróć ⍵ bez zmian.
• ⍎¨⍕⍵: zamień ⍵ na ciąg, a następnie oceń każdy znak
• 2-/: odejmuj co dwie sąsiednie liczby
• |: weź wartości bezwzględne
• 10⊥: zamień tablicę na liczbę podstawową 10
• ⍵+∇: wywołaj funkcję rekurencyjnie z tą nową wartością i dodaj wynik do wejścia

Mathematica, 72 69 65 bajtów

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

Jestem otwarty na sugestie tutaj.

JavaScript ES6, 73 bajty

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

To nie jest coraz krótsze: / Spróbuję więcej podejść, ale jak dotąd jest to najkrótszy

JavaScript (ES6), 69

Testować uruchomienie poniższego fragmentu w przeglądarce zgodnej z EcmaScript 6 (ale nie w Chrome, ponieważ nadal nie obsługuje on operatora rozprzestrzeniania ...) Może MS Edge?

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>

Alternatywnie, przy użyciu rozumienia tablic, które jest obecnie ukierunkowane na EcmaScript 2016 (ES7), 67 bajtów:

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 bajtów

Kiedyś lubiłem brak wyrażenia regularnego, dopóki nie próbowałem go użyć do tego wyzwania ... niere.findall('\d\d',s,overlapped=True) jest włączony;)

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)

Pozdrawiam @Todd :)

J, 70 bajtów

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

C 162 bajty

grał w golfa:

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

bez golfa:

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 bajtów

Kod

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

Przetestuj online .

Bez golfa

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

Oto wykres różnicy serii „Suma różnic cyfr” od f (1) do f (1m). Tylko dlatego, że lubię się różnić.

Kod działki

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

MATLAB (141)(137)

EDYCJA: 4 bajty mniej, dzięki @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

• Ta próba pobiła odpowiedź @LuisMendo, ale przynajmniej mogłem skrócić czas wykonania, przez co właśnie próbowałbym zróżnicować sposoby rozwiązania tego problemu.
• Mógłbym to bardziej zmniejszyć, ale w miarę upływu czasu tracę więcej bajtów, więc oto zasada:

Program sumuje cyfry tego samego wiersza przed cyframi wstawionymi, co oznacza, że ​​używał tylko dzielenia liczb całkowitych „n / 10” log_10 (n) razy, złożoność wynosi O (N).

Jeśli n= a b c d

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

Mój program oblicza:

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

Stosowanie:

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

a =

1

 b =

   16098

Prolog, 143 bajty

Kod:

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

Wyjaśniono:

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 wykonuje obliczenia, które konwertują liczbę na różnicę cyfr.
r rekurencyjnie wywołuje q i podsumowuje wyniki, aby znaleźć sumę różnicy cyfr.
p jest punktem wejścia. Pobiera numer, dzwoni r i drukuje odpowiedź.

Przykład:

>p(8675309).
8898683

Wypróbuj online tutaj .

PHP - 198 bajtów

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

Bez golfa

<?
$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 bajtów

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

stosowanie:

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