Jumlah Modulo Jumlah

34

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 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
AdmBorkBork
sumber

Jawaban:

10

05AB1E , 12 10 byte

v¹¹N¹‚£O%O

Menggunakan pengkodean CP-1252 . Cobalah online!

Adnan
sumber
3
bagus, tidak memuat ulang dan memposting D.s¨s.p¨R+¹s%Otanpa melihat ini; P
Magic Octopus Mm
9

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

Washington Guedes
sumber
2
Cuplikan itu cukup rapi, melihatnya diperbarui secara real-time seperti itu.
AdmBorkBork
Bisakah Anda menyimpan byte dengan melakukan (+'$&$''+$`)?
Neil
@Neil. Pada iterasi pertama $`kosong, dan itu akan membuang kesalahan mencoba untuk eval (13+)(sebagai contoh).
Washington Guedes
7

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               
Fatalisasi
sumber
6

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

zeppelin
sumber
Jika Anda membatasi diri m<2**31Anda maka Anda bisa mulai dengan x=1penghematan satu byte.
Neil
6

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.

Tidak
sumber
6

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
Jonathan Allan
sumber
5

Perl 35 32 27 Bytes

Termasuk +3 untuk -p

Disimpan 8 byte berkat Dada

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

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));
}
Mukul Kumar
sumber
Anda harus init r=0sedemikian rupa sehingga jika fungsi dipanggil lagi hasilnya benar. Di suatu tempat di Meta, jika Anda menggunakan variabel global maka Anda harus berurusan dengan efek samping dari memanggil fungsi lebih dari sekali.
Karl Napf
@ KarlNapf itu bagus?
Mukul Kumar
C tidak mengizinkan nilai fungsi default, kode Anda tidak dikompilasi. Anda dapat mendeklarasikan rglobal tetapi di dalam fungsinya sebagai pernyataan yang dapat Anda katakan r=0;, lihat jawaban saya misalnya.
Karl Napf
1
@ KarlNapf ans Anda adalah v2 dari ans saya ... terima kasih jauh lebih baik
Mukul Kumar
5

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

tongkat
sumber
Hemat 4:lambda n:sum(int(n)%eval(n[:i]+'+'+n[i:])for i in range(len(n)))
ahli atlasologi
1
Gagal untuk input yang berisi nol dengan 8atau 9setelahnya dan memberikan jawaban yang salah untuk orang lain (seperti kasus uji terakhir). Angka yang dimulai dengan nol adalah oktal. repl.it/EmMm
mbomb007
@ mbomb007 diperbaiki
Rod
4

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));
}
Karl Napf
sumber
Ohhh .... tolong tambahkan penjelasan.
Mukul Kumar
@MukulKumar oke seperti ini?
Karl Napf
ya itu bagus.
Mukul Kumar
3

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.

Martin Ender
sumber
3

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
TheBikingViking
sumber
3

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
}
Brad Gilbert b2gills
sumber
3

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.

Martin Ender
sumber
3

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.
Sherlock9
sumber
Jika Anda memindahkan ╜% di dalam bagian fungsi Anda tidak perlu menggunakan ♀ dan itu akan menghemat 1 byte: D (; ╗ $ lr ╤╜d+╜%MΣ)
Teal pelican
@Tealpelican Terima kasih atas tipnya: D Beri tahu saya jika Anda menemukan saran bermain golf lainnya
Sherlock9
2

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

Lee W
sumber
Sayangnya, Ruby menafsirkan literal bilangan bulat yang dimulai dengan 0oktal, artinya ini gagal untuk kasus uji terakhir. Berikut adalah solusi 78-byte yang mengatasinya.
benj2240
2

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.
James Holderness
sumber
2

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
Zacharý
sumber
Di sana, sudah selesai.
Zacharý
2

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
    }
}
adrianmp
sumber
2

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
Conor O'Brien
sumber
1

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.

NikoNyrh
sumber
1

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
juga
sumber
Begitu banyak orangtua dekat ...: D
AdmBorkBork
Tidak sesulit kelihatannya.
rnso
0

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.

Philip Weiss
sumber
Maaf! Ini adalah solusi 45 byte yang ditulis dalam ruby. Saya telah mengedit posting untuk mencerminkan hal itu.
Philip Weiss
Runner-up 46 byte: ->q{(0..q).reduce{|s,x|p=10**x;s+q%(q/p+q%p)}}
Philip Weiss
0

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
Shaggy
sumber
1
Ini ditandai sebagai kualitas rendah: P
Christopher