整数が与えられた場合n > 9、その整数の数字の間に可能な挿入ごとに、追加+を挿入して評価します。次に、それらの結果を法として元の数を取ります。これらの操作の合計を出力します。

以下の例n = 47852：

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

入力

任意の便利な形式の単一の正の整数、n > 9。

出力

上記の構築手法に従った単一の整数出力。

ルール

• あなたの言語のデフォルトのタイプより大きい入力を心配する必要はありません。
• 完全なプログラムまたは機能のいずれかが受け入れられます。関数の場合、出力する代わりに出力を返すことができます。
• 標準抜け穴は禁止されています。
• これはコードゴルフなので、通常のゴルフルールがすべて適用され、最短のコード（バイト単位）が勝ちます。

例

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

05AB1E、12 10バイト

v¹¹N¹‚£O%O

CP-1252エンコードを使用します。オンラインでお試しください！

JavaScript、43 47バイト

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

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

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

入力を文字列として受け取ります。

編集：

+4バイト：JavaScriptの先頭のゼロは数値を8進数に変換します）：

Brachylog、20バイト

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

オンラインでお試しください！

説明

これにより、指定された式が実装されます。注意する必要があるのは、a 0が入力の途中にあるときだけです。その場合、Brachylogはかなり風変わりになります。たとえば、aで始まる整数のリストを0連結して整数にできることを受け入れません（先行を無視する必要があります0-これは主に無限ループを回避するようにプログラムされています）。したがって、この問題を回避するために、入力を文字列に変換してから、すべての分割された入力を整数に変換します。

                       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）、 42、40バイト

編集：

• GOTはを取り除くS、-2バイト

ゴルフ

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

テスト

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バイト

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

文字列ではなく算術を使用して、入力nをn/c、およびに分割します。n%cこれcは、10の累乗で再帰します。

ゼリー、12 バイト

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

TryItOnline！

どうやって？

ŒṖṖ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バイト

+3を含む -p

Dadaのおかげで8バイト節約

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

C 77 + 4 = 81バイト

ゴルフをした

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

非ゴルフ

#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バイト

^{アトラロジストのおかげで-4バイト}

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

^{*入力は文字列です}

C、59バイト

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

tは10,100,1000,...、多数のカットを表します。n/t右部分とn%t左部分です。場合tの数よりも大きい、それが終了します。

ゴルフをしないと使用法：

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

網膜、38バイト

バイトカウントはISO 8859-1エンコードを前提としています。

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

1

正確ではない...

オンラインでお試しください！（最初の行は、改行で区切られたテストスイートを有効にします。）

説明

\B
,$';$_¶$`

文字の各ペアの間に、コンマ、一致の前にあるすべて、セミコロン、入力全体、改行、および一致後のすべてを挿入します。入力の場合、次の12345ようになります。

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

すなわち、入力のペアとともに入力の可能なすべての分割。ただし、最後の行は必要ありません。

G-2`

破棄します。

\d+|,
$*

これにより、各数値とコンマが単項表現に置き換えられます。コンマは数字ではないため、ゼロとして扱われ、単純に削除されます。これにより、各分割に2つの部分が追加されます。

(1+);\1*

これは、最初の数値のすべてのコピーを2番目の数値から削除することにより、モジュロを計算します。

1

それだけ1です。文字列に残っているの数を数えて、結果として出力します。

Pyth、14バイト

s.e%QssMc`Q]k`

整数の入力を受け取り、結果を出力するプログラム。

テストスイート

使い方

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バイト

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

関数を定義しますf。 すべてのテストケースに合格することを確認してください。

Perl 6、33バイト

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

拡張：

{                  # 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バイト

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

これは、数字のリストでパターンマッチングを使用して、数字のすべてのパーティションを2つの部分に抽出します。かかる各パーティションaとbその後に置き換えられ

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

ここで注目すべき事があれば例えばので、不等長のリストの合計は、未評価のままであることでaある1,2とbされ3,4,5、その後、我々は最初にこれを置き換えます{1,2} + {3,4,5} + {}。最後の用語は、偶数の桁を均等に分割したときに、評価されないままになるようにするためのものです。MapMathematica の操作は十分に一般化されており、リストだけでなくあらゆる種類の式で動作します。したがって、FromDigitsこの合計をマップすると、それらのリストのそれぞれが数値に戻ります。その時点で、式は整数の合計になり、評価されます。これによりTr[FromDigits/@{{a},{b}}]、2つのリストを最初に変換してから結果を合計する従来のソリューションに比べて1バイト節約できます。

実際には、16 15バイト

ゴルフの提案を歓迎します！オンラインでお試しください！

編集：ティールペリカンのおかげで-1バイト。

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

アンゴルフ

         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.

ルビー、64バイト

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

入力を文字列として受け取ります

Befunge、101 96バイト

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

オンラインでお試しください！

説明

&              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バイト

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

⎕IOでなければなりません1。説明（私はこれまでどんなimporvementsがされて、説明するのが得意じゃない非常に歓迎）：

{+/⍵|⍨{(⍎⍵↑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バイト

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

ungolfedの完全なプログラム、説明された方法とテストケース：

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

アタッシュ、48バイト

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

オンラインでお試しください！

説明

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バイト

編集：これは、匿名関数(fn[v](->> ...))を宣言し、->>マクロを使用しないため、読み取りおよび呼び出し方が簡単だったため、短くなります。

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

元の：

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

1、10、100、...のシーケンスを生成し、最初の10項目を取得し（入力値が10 ^ 11未満であると仮定）、specsで指定されたモジュロにマップし、合計を計算します。関数名が長いとこのソリューションは非常に長くなりますが、少なくともゴルフバージョンでも簡単に理解できるはずです。

最初に文字列をジャグリングしてみましたが、大量の定型文が必要でした。

ラケット134バイト

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

ゴルフをしていない：

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

テスト：

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

出力：

5842
1
6
2097
8331
505598476

R、50バイト

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

オンラインでお試しください！

SNOBOL4（CSNOBOL4）、92バイト

	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

オンラインでお試しください！

Ruby 45バイト

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

これは本当にすてきなソリューションです。技術的には正しいのですが、非常に非効率的です。q.to_s.size.times {...}を記述する方がはるかに効率的です。q.timesを使用するのは、文字を保存するためです。また、procを通過する余分な回数は、式がゼロと評価するだけです。

PHP、60バイト

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

オンラインでお試しください！

Java 8、127 66バイト

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

@adrianmpのC＃回答のポートを作成して-61バイト。

ここで試してみてください。

パリ/ GP、42バイト

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

オンラインでお試しください！

Japt、11 10バイト

¬x@%OvUi+Y

それを試してみてください

説明

               :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