Fügen Sie n > 9für jede mögliche Einfügung zwischen Ziffern in dieser Ganzzahl eine Addition ein +und bewerten Sie sie mit einer Ganzzahl . Nehmen Sie dann die ursprüngliche Zahl, um diese Ergebnisse zu modulieren. Die Gesamtsumme dieser Operationen ausgeben.

Ein Beispiel mit n = 47852:

47852 % (4785+2) = 4769
47852 % (478+52) =  152
47852 % (47+852) =  205
47852 % (4+7852) =  716
                  -----
                   5842

Eingang

Eine einzelne positive ganze Zahl in jedem geeigneten Format , n > 9.

Ausgabe

Die Ausgabe einer einzelnen Ganzzahl gemäß der obigen Konstruktionstechnik.

Regeln

• Sie müssen sich keine Gedanken über Eingaben machen, die größer sind als der Standardtyp Ihrer Sprache.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

47852 -> 5842
13 -> 1
111 -> 6
12345 -> 2097
54321 -> 8331
3729105472 -> 505598476

05AB1E , 12 10 Bytes

v¹¹N¹‚£O%O

Verwendet die CP-1252- Codierung. Probieren Sie es online!

JavaScript, 43 47 Bytes

f=
n=>eval(n.replace(/./g,'+'+n+"%($`+ +'$&$'')"))

I.oninput=_=>O.value=f(I.value)

<input id=I>
<input id=O disabled>

Übernimmt die Eingabe als String.

Bearbeiten:

+4 Bytes : Führende Nullen in JavaScript konvertieren die Zahl in Oktal):

Brachylog , 20 Bytes

:{$@~c#C:@$a+:?r%}f+

Probieren Sie es online!

Erläuterung

Dies implementiert die angegebene Formel. Das Einzige, worauf wir achten müssen, ist, wenn sich a 0in der Mitte der Eingabe befindet: In diesem Fall wird Brachylog ziemlich schrullig. Beispielsweise wird nicht akzeptiert, dass eine Liste von Ganzzahlen, die mit a beginnen 0, zu einer Ganzzahl verkettet werden kann ( die die führende ignorieren würde erfordern 0- das so programmiert ist , in erster Linie auf diese Weise Endlosschleifen zu vermeiden). Um dieses Problem zu umgehen, konvertieren wir die Eingabe in eine Zeichenfolge und konvertieren dann alle geteilten Eingaben in Ganzzahlen zurück.

                       Example Input: 47852

:{               }f    Find all outputs of that predicate: [716,205,152,4769]
  $@                     Integer to String: "47852"
    ~c#C                 #C is a list of two strings which when concatenated yield the Input
                           e.g. ["47","852"]. Leave choice points for all possibilities.
        :@$a             Apply String to integer: [47,852]
            +            Sum: 899
             :?r%        Input modulo that result: 205
                   +   Sum all elements of that list               

ES6 (Javascript), 4240 Bytes

EDITS:

• Wurde s , -2 Bytes los

Golf gespielt

M=(m,x=10)=>x<m&&m%(m%x+m/x|0)+M(m,x*10)

Prüfung

M=(m,x=10)=>x<m&&m%(m%x+m/x|0)+M(m,x*10);

[47852,13,111,12345,54321,3729105472].map(x=>console.log(M(x)));

Python 2, 45 Bytes

f=lambda n,c=10:n/c and n%(n/c+n%c)+f(n,c*10)

Verwendet Arithmetik anstelle von Zeichenfolgen, um die Eingabe nin Teile n/cund zu teilen n%c, die cdurch Potenzen von 10 rekursiv sind.

Gelee , 12 Bytes

ŒṖṖLÐṂḌS€⁸%S

TryItOnline!

Wie?

ŒṖṖLÐṂḌS€⁸%S - Main link: n
ŒṖ           - partitions (implicitly treats the integer n as a list of digits)
  Ṗ          - pop - remove the last partition (the one with length one)
    ÐṂ       - keep those with minimal...
   L         - length (now we have all partitions of length 2)
      Ḍ      - undecimal (convert each entry back to an integer)
       S€    - sum each (add the pairs up)
         ⁸   - left argument, n
          %  - mod (vectorises)
           S - sum

Perl 35 32 27 Bytes

Beinhaltet +3 für -p

8 Bytes dank Dada gespart

$\+=$_%($`+$')while//g}{

C 77 + 4 = 81 Bytes

Golf gespielt

i,N,t,r,m;f(n){for(r=0,m=n;n;t=n%10,n/=10,N+=t*pow(10,i++),r+=m%(n+N));return r;}  

Ungolfed

#include<stdio.h>
#include<math.h>

i,N,t,r,m;

f(n)
{
    m=n;
    r=0;
    while(n)
    {
        t=n%10;
        n/=10;
        N+=t*pow(10,i++);
        r+=m%(n+N);
    }
    return r;
}

main()
{
    printf("%d",f(47852));
}

Python 2, 68 64 68 Bytes

^{-4 Bytes dank Atlasologe}

lambda x:sum(int(x)%(int(x[:i])+int(x[i:]))for i in range(1,len(x)))

^{* Die Eingabe ist eine Zeichenfolge}

C 59 Bytes

t,s;f(n){s=0;t=10;while(t<n)s+=n%(n/t+n%t),t*=10;return s;}

tist 10,100,1000,...und repräsentiert den Schnitt in der großen Zahl. n/tist der rechte Teil und n%tder linke Teil. Wenn tgrößer als die Zahl ist, ist es fertig.

Ungolfed und Nutzung:

t,s;
f(n){
 s=0;
 t=10;
 while(t<n)
  s += n % (n/t + n%t),
  t *= 10;
 return s;
}

main(){
 printf("%d\n",f(47852));
}

Retina , 38 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

\B
,$';$_¶$`
G-2`
\d+|,
$*
(1+);\1*

1

Nicht gerade effizient ...

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

\B
,$';$_¶$`

Zwischen jedem Zeichenpaar wird ein Komma eingefügt, alles vor dem Match, ein Semikolon, die gesamte Eingabe, ein Zeilenvorschub und alles nach dem Match. Für die Eingabe 12345gibt uns dies:

1,2345;12345
12,345;12345
123,45;12345
1234,5;12345
12345

Dh jede mögliche Aufteilung der Eingabe zusammen mit einem Paar der Eingabe. Diese letzte Zeile brauchen wir aber nicht:

G-2`

Wir werfen es weg.

\d+|,
$*

Dies ersetzt jede Zahl sowie das Komma durch ihre unäre Darstellung. Da das Komma keine Zahl ist, wird es als Null behandelt und einfach entfernt. Dies addiert die beiden Teile in jeder Aufteilung.

(1+);\1*

Dies berechnet das Modulo, indem alle Kopien der ersten Nummer von der zweiten Nummer entfernt werden.

1

Das war's, wir zählen einfach, wie viele 1s in der Zeichenkette übrig sind und geben das als Ergebnis aus.

Pyth, 14 Bytes

s.e%QssMc`Q]k`

Ein Programm, das die Eingabe einer Ganzzahl akzeptiert und das Ergebnis ausgibt.

Testsuite

Wie es funktioniert

s.e%QssMc`Q]k`   Program. Input: Q
s.e%QssMc`Q]k`Q  Implicit input fill
 .e          `Q  Map over str(Q) with k as 0-indexed index:
        c`Q]k     Split str(Q) into two parts at index k
      sM          Convert both elements to integers
     s            Sum
   %Q             Q % that
s                Sum
                 Implicitly print

Haskell, 62 Bytes

f x|m<-mod x=sum[m$div x(10^k)+m(10^k)|(k,_)<-zip[0..]$show x]

Definiert eine Funktion f. Sehen Sie, wie alle Testfälle bestanden werden.

Perl 6 , 33 Bytes

{sum $_ X%m:ex/^(.+)(.+)$/».sum}

Erweitert:

{                  # bare block lambda with implicit parameter ｢$_｣

  sum

    $_             # the input

    X%             # cross modulus

    m :exhaustive /  # all possible ways to segment the input
      ^
      (.+)
      (.+)
      $
    /».sum         # sum the pairs
}

Mathematica, 75 Bytes

Tr@ReplaceList[IntegerDigits@#,{a__,b__}:>Mod[#,FromDigits/@({a}+{b}+{})]]&

Hierbei wird der Mustervergleich in der Ziffernliste verwendet, um alle Partitionen in zwei Teile zu extrahieren. Jede solche Partition in aund bwird dann durch ersetzt

Mod[#,FromDigits/@({a}+{b}+{})]

Das Bemerkenswerte dabei ist, dass Summen von Listen mit ungleicher Länge unbewertet bleiben. Wenn also z. B. aist 1,2und bist, 3,4,5ersetzen wir dies zuerst durch {1,2} + {3,4,5} + {}. Der letzte Term soll sicherstellen, dass er immer noch unbewertet bleibt, wenn wir eine gerade Anzahl von Ziffern gleichmäßig aufteilen. Jetzt ist die MapOperation in Mathematica so verallgemeinert, dass sie mit jeder Art von Ausdruck funktioniert, nicht nur mit Listen. Wenn wir also FromDigitsdiese Summe addieren, wird jede dieser Listen wieder zu einer Zahl. Zu diesem Zeitpunkt ist der Ausdruck eine Summe von ganzen Zahlen, die nun ausgewertet werden. Dies spart ein Byte gegenüber der herkömmlicheren Lösung Tr[FromDigits/@{{a},{b}}], bei der zuerst die beiden Listen konvertiert und dann das Ergebnis summiert werden.

Eigentlich , 16 15 Bytes

Golfvorschläge willkommen! Probieren Sie es online!

Bearbeiten: -1 Byte dank Teal Pelican.

;╗$lr`╤╜d+╜%`MΣ

Ungolfing

         Implicit input n.
;╗       Save a copy of n to register 0.
$l       Yield the number of digits the number has, len_digits.
r        Yield the range from 0 to len_digits - 1, inclusive.
`...`M   Map the following function over that range, with variable x.
  ╤        Yield 10**x.
  ╜        Push a copy of n from register 0.
  d        Push divmod(n, 10**x).
  +        Add the div to the mod.
  ╜        Push a copy of n from register 0.
  %        Vectorized modulo n % x, where x is a member of parition_sums.
         This function will yield a list of modulos.
Σ        Sum the results together.
         Implicit return.

Ruby, 64 Bytes

->s{s.size.times.reduce{|a,i|a+s.to_i%eval(s[0,i]+?++s[i..-1])}}

Nimmt die Eingabe als String

Befunge, 101 96 Bytes

&10v
`#v_00p:::v>+%\00g1+:9
*v$v+55g00</|_\55+
\<$>>\1-:v ^<^!:-1 
+^+^*+55\_$%\00g55
.@>+++++++

Probieren Sie es online!

Erläuterung

&              Read n from stdin.
100p           Initialise the current digit number to 1.

               -- The main loop starts here --

:::            Make several duplicates of n for later manipulation.

v+55g00<       Starting top right, and ending bottom right, this
>>\1-:v          routine calculates 10 to the power of the
^*+55\_$         current digit number.

%              The modulo of this number gives us the initial digits.
\              Swap another copy of n to the top of the stack.

_\55+*v        Starting bottom left and ending top left, this
^!:-1\<          is another calculation of 10 to the power of
00g55+^          the current digit number.

/              Dividing by this number gives us the remaining digits.
+              Add the two sets of digits together.
%              Calculate n modulo this sum.
\              Swap the result down the stack bringing n back to the top.

00g1+          Add 1 to the current digit number.
:9`#v_         Test if that is greater than 9.
00p            If not, save it and repeat the main loop.

               -- The main loop ends here --

$$             Clear the digit number and N from the stack.
++++++++       Sum all the values that were calculated.
.@             Output the result and exit.

APL, 29 Bytes

{+/⍵|⍨{(⍎⍵↑R)+⍎⍵↓R}¨⍳⍴1↓R←⍕⍵}

⎕IOmuss sein 1. Erklärung (Ich bin nicht gut darin zu erklären, irgendwelche Verbesserungen sind sehr willkommen):

{+/⍵|⍨{(⍎⍵↑R)+⍎⍵↓R}¨⍳⍴1↓R←⍕⍵}
{                           } - Function (Monadic - 1 argument)
                           ⍵  - The argument to the function
                          ⍕   - As a string
                        R←    - Stored in R
                      1↓      - All except the first element
                    ⍳⍴        - 1 to the length
      {           }           - Another function
               ⍵↓R            - R without ⍵ (argument of inner function) leading digits
              ⍎               - As a number
             +                - Plus
       (    )                 - Grouping
         ⍵↑R                  - The first ⍵ digits of R
        ⍎                     - As a number
                   ¨          - Applied to each argument
   ⍵|⍨                        - That modulo ⍵ (outer function argument)
 +/                           - Sum

C #, 67 Bytes

n=>{long d=n,s=0,p=1;while(d>9)s+=n%((d/=10)+n%(p*=10));return s;};

Volles Programm mit ungolfederten, erklärten Methoden und Testfällen:

using System;

public class Program
{
    public static void Main()
    {
        Func<long,long> f=
        n=>
        {
            long d = n, // stores the initial number
                 r,         // remainder, stores the last digits
                 s = 0, // the sum which will be returned
                 p = 1; // used to extract the last digit(s) of the number through a modulo operation
            while ( d > 9 ) // while the number has more than 1 digit
            {
                d /= 10;    // divides the current number by 10 to remove its last digit
                p *= 10;    // multiplies this value by 10
                r = n % p;  // calculates the remainder, thus including the just removed digit
                s += n % (d + r);   // adds the curent modulo to the sum
            }
            return s;   // we return the sum
        };

        // test cases:
        Console.WriteLine(f(47852)); //5842
        Console.WriteLine(f(13));   // 1
        Console.WriteLine(f(111));  // 6
        Console.WriteLine(f(12345));    // 2097
        Console.WriteLine(f(54321));    // 8331
        Console.WriteLine(f(3729105472));   // 505598476
    }
}

Attache , 48 Bytes

Sum@{N[_]%Sum@Map[N]=>SplitAt[_,1..#_-1]}@Digits

Probieren Sie es online!

Erläuterung

Sum@{N[_]%Sum@Map[N]=>SplitAt[_,1..#_-1]}@Digits
                                          Digits    convert input to digits
    {                                   }@          call lambda with digits as argument
                      SplitAt[_,1..#_-1]            split digits at each partition
              Map[N]=>                              Map N to two-deep elements
          Sum@                                      Takes the sum of each sub array
     N[_]%                                          convert digits to int and vector mod
Sum@                                                sum the resultant array

Clojure, 91 81 Bytes

Bearbeiten: Dies ist kürzer, da es eine anonyme Funktion deklariert (fn[v](->> ...))und kein ->>Makro verwendet, obwohl es einfacher zu lesen und so aufzurufen war.

(fn[v](apply +(map #(mod v(+(quot v %)(mod v %)))(take 10(iterate #(* 10 %)1)))))

Original:

(defn s[v](->> 1(iterate #(* 10 %))(take 10)(map #(mod v(+(quot v %)(mod v %))))(apply +)))

Erzeugt eine Sequenz von 1, 10, 100, ... und nimmt die ersten 10 Elemente (unter der Annahme, dass die Eingabewerte kleiner als 10 ^ 11 sind), ordnet sie Modulos zu, wie in den Spezifikationen angegeben, und berechnet die Summe. Lange Funktionsnamen machen diese Lösung ziemlich lang, aber zumindest sollte auch die Golfversion leicht zu befolgen sein.

Zuerst habe ich versucht, Saiten zu jonglieren, aber dafür war eine Menge Kochplatte erforderlich.

Schläger 134 Bytes

(let((s(number->string n))(h string->number)(g substring))(for/sum((i(range 1(string-length s))))(modulo n(+(h(g s 0 i))(h(g s i))))))

Ungolfed:

(define (f n)
  (let ((s (number->string n))
        (h string->number)
        (g substring))
    (for/sum ((i (range 1 (string-length s))))
      (modulo n (+ (h (g s 0 i)) (h (g s i)))))))

Testen:

(f 47852)
(f 13)
(f 111)
(f 12345)
(f 54321)
(f 3729105472)

Ausgabe:

5842
1
6
2097
8331
505598476

R , 50 Bytes

function(n)sum(n%%(n%%10^(x=1:nchar(n))+n%/%10^x))

Probieren Sie es online!

SNOBOL4 (CSNOBOL4) , 92 Bytes

	N =INPUT
S	N LEN(X) . L REM . R	:F(O)
	S =S + REMDR(N,L + R)
	X =X + 1	:(S)
O	OUTPUT =S
END

Probieren Sie es online!

Ruby 45 Bytes

->q{t=0;q.times{|x|p=10**x;t+=q%(q/p+q%p)};t}

Dies ist eine wirklich saubere Lösung. Es ist technisch korrekt, aber es ist super ineffizient. Es wäre viel effizienter, q.to_s.size.times {...} zu schreiben. Wir verwenden q.times, weil es Zeichen speichert und der Ausdruck für die zusätzliche Häufigkeit, mit der er den Prozess durchläuft, nur null ergibt.

PHP , 60 Bytes

for($n=1;($n*=10)<$a=$argn;)$r+=$a%(($a/$n^0)+$a%$n);echo$r;

Probieren Sie es online!

Java 8, 127 66 Bytes

n->{long m=n,r=0,p=1;for(;m>9;r+=n%((m/=10)+n%(p*=10)));return r;}

-61 Bytes durch Erstellen eines Ports der C # - Antwort von @adrianmp .

Probieren Sie es hier aus.

Pari / GP , 42 Bytes

n->sum(i=1,logint(n,10),n%(n\10^i+n%10^i))

Probieren Sie es online!

Japt , 11 10 Bytes

¬x@%OvUi+Y

Versuch es

Erläuterung

               :Implicit input of string U
¬              :Split to an array of characters
  @            :Pass each character at index Y through a function
      Ui+Y     :  Insert a + in U at index Y
    Ov         :  Evaluate as Japt
   %           :  Modulo U by the above
 x             :Reduce by addition