Diberikan bilangan bulat n > 9, untuk setiap kemungkinan penyisipan antara digit dalam bilangan bulat itu, masukkan tambahan +dan evaluasi. Kemudian, ambil nomor asli modulo hasil tersebut. Keluarkan jumlah total dari operasi ini.

Contoh dengan n = 47852:

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

Memasukkan

Sebuah bilangan bulat positif dalam format yang nyaman , n > 9.

Keluaran

Output integer tunggal mengikuti teknik konstruksi di atas.

Aturan

• Anda tidak perlu khawatir tentang input yang lebih besar dari tipe default bahasa Anda.
• Program lengkap atau fungsi dapat diterima. Jika suatu fungsi, Anda dapat mengembalikan output daripada mencetaknya.
• Celah standar dilarang.
• Ini adalah kode-golf sehingga semua aturan golf biasa berlaku, dan kode terpendek (dalam byte) menang.

Contohnya

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

05AB1E , 12 10 byte

v¹¹N¹‚£O%O

Menggunakan pengkodean CP-1252 . Cobalah online!

JavaScript, 43 47 byte

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

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

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

Mengambil input sebagai string.

Edit:

+4 byte : Memimpin nol dalam JavaScript mengubah angka menjadi oktal):

Brachylog , 20 byte

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

Cobalah online!

Penjelasan

Ini mengimplementasikan formula yang diberikan. Satu-satunya hal yang harus kita perhatikan adalah ketika a 0berada di tengah-tengah input: dalam hal itu Brachylog menjadi cukup unik, misalnya tidak akan menerima bahwa daftar bilangan bulat yang dimulai dengan a 0dapat digabungkan menjadi bilangan bulat ( yang akan memerlukan mengabaikan terkemuka 0- ini terutama diprogram seperti itu untuk menghindari loop tak terbatas). Oleh karena itu untuk menghindari masalah itu, kami mengubah input ke string dan kemudian mengkonversi kembali semua input yang dibagi menjadi bilangan bulat.

                       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 byte

EDIT:

• Singkirkan s , -2 byte

Golf

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

Uji

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 byte

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

Menggunakan aritmatika daripada string untuk membagi input nmenjadi bagian n/c- bagian dan n%c, yang cberulang melalui kekuatan 10.

Jelly , 12 byte

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

TryItOnline!

Bagaimana?

ŒṖṖ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

Termasuk +3 untuk -p

Disimpan 8 byte berkat Dada

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

C 77 + 4 = 81 byte

bermain golf

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

Tidak disatukan

#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 byte

^{-4 byte terima kasih kepada atlasologist}

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

^{* Input adalah sebuah string}

C, 59 byte

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

tadalah 10,100,1000,...dan mewakili potongan dalam jumlah besar. n/tadalah bagian kanan dan n%tkiri. Jika tlebih besar dari angka, itu selesai.

Tidak digabungkan dan digunakan:

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 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

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

1

Tidak tepat efisien ...

Cobalah online! (Baris pertama memungkinkan suite tes yang dipisahkan dengan linefeed.)

Penjelasan

\B
,$';$_¶$`

Di antara setiap pasangan karakter, kami menyisipkan koma, semua yang ada di depan pertandingan, titik koma, seluruh input, umpan baris, dan semuanya setelah pertandingan. Untuk input, 12345ini memberi kita:

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

Yaitu setiap kemungkinan pemisahan input bersama dengan sepasang input. Kami tidak membutuhkan baris terakhir itu:

G-2`

Kami membuangnya.

\d+|,
$*

Ini menggantikan setiap angka serta koma dengan representasi unary. Karena koma bukan angka, itu diperlakukan sebagai nol dan hanya dihapus. Ini menambahkan dua bagian di setiap pemisahan.

(1+);\1*

Ini menghitung modulo dengan menghapus semua salinan dari angka pertama dari angka kedua.

1

Itu saja, kita cukup menghitung berapa banyak 1yang tersisa dalam string dan mencetaknya sebagai hasilnya.

Pyth, 14 byte

s.e%QssMc`Q]k`

Program yang mengambil input bilangan bulat dan mencetak hasilnya.

Suite uji

Bagaimana itu bekerja

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 byte

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

Menentukan fungsi f. Lihat lulus semua kasus uji.

Perl 6 , 33 byte

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

Diperluas:

{                  # 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 byte

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

Ini menggunakan pencocokan pola pada daftar digit untuk mengekstraksi semua partisi menjadi dua bagian. Masing-masing partisi tersebut menjadi adan bkemudian diganti dengan

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

Hal penting di sini adalah bahwa jumlah dari daftar panjang yang tidak sama tetap unevaluated, jadi misalnya jika aadalah 1,2dan badalah 3,4,5kemudian kita pertama mengganti ini dengan {1,2} + {3,4,5} + {}. Istilah terakhir ada untuk memastikan bahwa itu masih tetap tidak dievaluasi ketika kita membagi angka secara merata. Sekarang Mapoperasi di Mathematica cukup digeneralisasikan sehingga bekerja dengan segala jenis ekspresi, bukan hanya daftar. Jadi, jika kita memetakan FromDigitsjumlah ini, itu akan mengubah masing-masing daftar itu kembali menjadi angka. Pada titik itu, ekspresi adalah jumlah bilangan bulat, yang sekarang akan dievaluasi. Ini menghemat satu byte dari solusi Tr[FromDigits/@{{a},{b}}]yang lebih konvensional yang mengubah dua daftar terlebih dahulu dan kemudian merangkum hasilnya.

Sebenarnya , 16 15 byte

Selamat datang saran bermain golf! Cobalah online!

Sunting: -1 byte berkat Teal pelican.

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

Tidak melakukanolf

         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 byte

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

Mengambil input sebagai string

Befunge, 101 96 byte

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

Cobalah online!

Penjelasan

&              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 byte

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

⎕IOharus 1. Penjelasan (Saya tidak bisa menjelaskan dengan baik, semua keperluan untuk ini sangat disambut baik):

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

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

Program lengkap dengan ungolfed, metode yang dijelaskan dan uji kasus:

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 byte

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

Cobalah online!

Penjelasan

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 byte

Sunting: ini lebih pendek karena menyatakan fungsi anonim (fn[v](->> ...))dan tidak menggunakan ->>makro meskipun lebih mudah untuk membaca dan memanggilnya.

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

Asli:

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

Menghasilkan urutan 1, 10, 100, ... dan mengambil 10 item pertama (dengan asumsi nilai input kurang dari 10 ^ 11), memetakan ke modulos seperti yang ditentukan dalam spesifikasi dan menghitung jumlahnya. Nama fungsi yang panjang membuat solusi ini cukup panjang tetapi setidaknya bahkan versi golf harus cukup mudah diikuti.

Pertama saya mencoba menyulap string tetapi membutuhkan banyak boilerplate.

Racket 134 byte

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

Tidak Disatukan:

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

Pengujian:

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

Keluaran:

5842
1
6
2097
8331
505598476

R , 50 byte

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

Cobalah online!

SNOBOL4 (CSNOBOL4) , 92 byte

	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

Cobalah online!

Ruby 45 Bytes

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

Ini adalah solusi yang sangat rapi. Secara teknis memang benar, tetapi sangat tidak efisien. Akan jauh lebih efisien untuk menulis q.to_s.size.times {...}. Kami menggunakan q.times karena menghemat karakter, dan jumlah tambahan kali melalui proc ekspresi hanya bernilai nol.

PHP , 60 byte

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

Cobalah online!

Java 8, 127 66 byte

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

-61 byte dengan membuat port jawaban C # @adrianmp .

Coba di sini.

Pari / GP , 42 byte

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

Cobalah online!

Japt , 11 , 10 byte

¬x@%OvUi+Y

Cobalah

Penjelasan

               :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