กำหนดจำนวนเต็ม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 แปลงตัวเลขเป็นฐานแปด):

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 ไบต์

การแก้ไข:

• ลบ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

บันทึก 8 ไบต์ขอบคุณ Dada

$\+=$_%($`+$')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;}  

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 ไบต์

^{-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มีขนาดใหญ่กว่าจำนวนจะเสร็จสิ้น

Ungolfed และการใช้งาน:

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+|,
$*

สิ่งนี้จะแทนที่แต่ละหมายเลขเช่นเดียวกับเครื่องหมายจุลภาคด้วยการเป็นตัวแทน unary เนื่องจากเครื่องหมายจุลภาคไม่ใช่ตัวเลขจึงถือว่าเป็นศูนย์และถูกลบทิ้ง สิ่งนี้จะเพิ่มสองส่วนในการแยกแต่ละครั้ง

(1+);\1*

สิ่งนี้คำนวณโมดูโลโดยการลบสำเนาทั้งหมดของหมายเลขแรกออกจากหมายเลขที่สอง

1

เพียงเท่านี้เราก็แค่นับว่ามีจำนวน1s เหลืออยู่ในสตริงและพิมพ์เป็นผลลัพธ์

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}+{})]]&

ใช้การจับคู่รูปแบบในรายการตัวเลขเพื่อแยกพาร์ติชันทั้งหมดออกเป็นสองส่วน แต่ละพาร์ติชันดังกล่าวเข้าaและbถูกแทนที่ด้วย

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

สิ่งที่น่าสังเกตว่านี่คือผลรวมของรายการที่มีความยาวไม่เท่ากันยังคงอยู่ unevaluated ดังนั้นเช่นถ้าaเป็น1,2และbเป็นแล้วเราเป็นครั้งแรกแทนที่นี้กับ3,4,5 {1,2} + {3,4,5} + {}คำสุดท้ายอยู่ที่นั่นเพื่อให้แน่ใจว่ายังคงไม่มีการประเมินค่าเมื่อเราแบ่งตัวเลขจำนวนเท่า ๆ กัน ตอนนี้การMapดำเนินการใน Mathematica นั้นได้รับการทำให้เป็นมาตรฐานโดยทั่วไปเพียงพอที่จะทำงานกับการแสดงออกทุกประเภท ดังนั้นถ้าเราแมปFromDigitsกับผลรวมนี้มันจะเปลี่ยนแต่ละรายการกลับเป็นตัวเลข ณ จุดนั้นนิพจน์คือผลรวมของจำนวนเต็มซึ่งตอนนี้ได้รับการประเมิน วิธีนี้จะช่วยประหยัดไบต์ในโซลูชันทั่วไปTr[FromDigits/@{{a},{b}}]ซึ่งจะแปลงทั้งสองรายการก่อนแล้วจึงสรุปผลลัพธ์

อันที่จริง , 16 15 ไบต์

ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ! ลองออนไลน์!

แก้ไข: -1 ไบต์ขอบคุณนกกระทุง Teal

;╗$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 ไบต์

->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←⍕⍵}

⎕IO1จะต้องเป็น คำอธิบาย (ฉันไม่เก่งในการอธิบายสิ่งสำคัญสำหรับสิ่งนี้ยินดีมาก ):

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

โปรแกรมเต็มรูปแบบที่ไม่ได้อธิบายวิธีการทดสอบและกรณีทดสอบ:

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) แม็พกับโมดูโลตามที่ระบุไว้ในรายละเอียดและคำนวณผลรวม ชื่อฟังก์ชั่นที่ยาวนานทำให้การแก้ปัญหานี้ค่อนข้างยาว แต่อย่างน้อยแม้แต่เวอร์ชั่น golfed ก็ควรจะติดตามได้ง่าย

ครั้งแรกที่ฉันลองเล่นกลสายรอบ ๆ แต่มันต้องมีจำนวนมากสำเร็จรูป

แร็กเก็ต 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))))))

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

การทดสอบ:

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

-61 ไบต์โดยการสร้างพอร์ตของ@adrianmp 's C # คำตอบ

ลองที่นี่

Pari / 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